# &katepart; uitbreiden

## Inleiding

Zoals elke geavanceerde tekstbewerkercomponent biedt &katepart; een aantal manieren om zijn functionaliteit uit te breiden. U kunt eenvoudige scripts schrijven om functionaliteit toe te voegen met JavaScript of verhoogde functionaliteit toevoegen aan de bewerkercomponent met Plug-ins voor de bewerkercomponent. Tenslotte, wanneer u &kate;, hebt uitgebreid, bent u welkom om met ons mee te doen en uw verbeteringen te delen met de wereld!

## Werken met syntaxisaccentuering

### Overzicht

Accentuering van syntaxis zorgt er voor dat de tekstbewerker automatisch tekst in verschillende stijlen/kleuren laat zien, afhankelijk van de functie van de tekenreeks in relatie tot het doel van het bestand. In broncode voor programma's bijvoorbeeld, kunnen besturingsstatements vet worden weergegeven, terwijl typen gegevens en commentaar een andere kleur krijgen dan de rest van de tekst. Dit verbetert de leesbaarheid van de tekst enorm en helpt de auteur dus om efficiënter en productiever te zijn.

Een Perl-functie, weergegeven met syntaxisaccentuering.

Een Perl-functie, weergegeven met syntaxisaccentuering.

Dezelfde Perl-functie, weergegeven zonder accentuering.

Dezelfde Perl-functie, weergegeven zonder accentuering.

Welke van de twee voorbeelden is gemakkelijker te lezen?

&kappname; komt met een flexibel, te configureren en capabel systeem voor accentuering van de syntaxis en de standaard distributie levert definities voor een brede reeks van programmeer-, script- en markup-talen en andere formaten van tekstbestanden. Bovendien kunt u uw eigen definities leveren in eenvoudige &XML;-bestanden.

&kappname; zal automatisch de juiste syntaxisregels detecteren wanneer u een bestand opent, gebaseerd op het &MIME;-type van het bestand, bepaald door zijn extensie of, als deze er geen heeft, de inhoud. Ervaart u een foute keuze, dan kunt u handmatig de te gebruiken syntaxis instellen uit het menu Hulpmiddelen Accentuering.

De stijlen en kleuren die door elke definitie voor syntaxisaccentuering kan worden ingesteld met het tabblad Accentuering van tekststijlen van de Instellingendialoog, terwijl de &MIME;-types en bestandsextensies waarvoor ze gebruikt zouden moeten worden, worden behandeld door het tabblad Modi & bestandstypen.

Syntaxisaccentuering is er om de leesbaarheid van correcte tekst te verhogen, maar u kunt het niet vertrouwen om uw tekst te valideren. Tekst markeren voor syntaxis is moeilijk, afhankelijk van het formaat dat u gebruikt en in sommige gevallen zullen de auteurs van de syntaxisregels trots zijn als 98% van de tekst juist wordt weergegeven, hoewel u meestal een zeldzame stijl nodig hebt om de onjuiste 2% tegen te komen.

U kunt bijgewerkte of extra definities voor syntaxisaccentuering downloaden van de &kappname;-website door op de knop Accentueringsbestanden downloaden... te klikken in het tabblad Modi & bestandstypen van de Instellingendialoog.

### Het systeem voor syntaxisaccentuering van &kappname;

Deze sectie zal het mechanisme voor syntaxisaccentuering van &kappname; in meer detail laten zien. Het is er voor u als u er iets over wilt weten of als u syntaxis-definities wilt veranderen of aanmaken.

#### Hoe het werkt

Wanneer u een bestand opent, is een van de eerste dingen die de tekstbewerker &kappname; doet, het detecteren van welke syntaxis-definitie voor het bestand moet worden gebruikt. Terwijl de tekst van het bestand wordt ingelezen en terwijl u het intypt, zal het systeem voor syntaxisaccentuering de tekst analyseren met de regels gedefinieerd door de syntaxis-definitie en het markeren waar verschillende contexten en stijlen beginnen en eindigen.

Tijdens het typen van het document wordt de nieuwe tekst geanalyseerd en direct gemarkeerd, zodat wanneer u een teken verwijdert die is gemarkeerd als het begin van einde van een context, de stijl van de tekst er omheen overeenkomstig wijzigt.

De syntaxis-definities die door het systeem voor syntaxisaccentuering van &kappname; wordt gebruikt zijn &XML;-bestanden, bevattende

- Regels voor detecteren van de rol van tekst, georganiseerd in contextblokken

- Lijsten met sleutelwoorden

- Definities van stijl-items

Bij het analyseren van de tekst worden de detectieregels geëvalueerd in de volgorde waarin ze zijn gedefinieerd en, als het begin van de huidige tekenreeks overeenkomt met een regel, wordt de gerelateerde context gebruikt. Het beginpunt in de tekst wordt verplaatst naar het eindpunt waarop die regel overeenkomt en een nieuwe ronde van de regels begint, beginnend in de context ingesteld door de overeenkomende regel.

#### Regels

De detectieregels zijn het hart van het detectiesysteem voor accentuering. Een regel is een tekenreeks, teken of reguliere expressie waartegen de tekst die wordt geanalyseerd wordt vergeleken. Het bevat informatie over welke stijl te gebruiken voor het overeenkomende deel van de tekst. Het kan de in werking zijnde context van het system omschakelen ofwel naar een expliciet genoemde context of naar de vorige context in gebruik bij de tekst.

Regels zijn georganiseerd in contextgroepen. Een contextgroep wordt gebruikt voor hoofdtekstconcepten in het formaat, bijvoorbeeld tekenreeksen tussen aanhalingstekens of commentaarblokken in broncode van programma's. Dit zorgt ervoor dat het accentueringssysteem niet door alle regels hoeft te doorlopen wanneer het niet noodzakelijk is en dat sommige tekenreeksen in de tekst anders kan worden behandeld afhankelijk van de huidige context.

Contexts kunnen dynamisch worden gegenereerd om het gebruik van specifieke gegevens bij toestanden in regels toe te staan.

#### Contextstijlen en sleutelwoorden

In sommige programmeertalen worden door de compiler (het programma dat de broncode vertaald in een binair uitvoerbaar programma) gehele getallen anders behandeld dan drijvendekommagetallen en er kunnen tekens zijn met een speciale betekenis in een tekenreeks tussen aanhalingsteken. In zulke gevallen, is het zinvol om ze verschillend weer te geven in hun omgeving zodat ze gemakkelijk zijn te identificeren bij het lezen van de tekst. Dus zelfs als ze speciale contexts representeren, kunnen ze als zodanig door het systeem voor accentuering van syntaxis worden gezien, zodat ze gemarkeerd kunnen worden voor een anders weergeven.

Een syntaxis-definitie kan zoveel stijlen bevatten als nodig is om de concepten van het formaat te dekken waarvoor het wordt gebruikt.

In vele formaten zijn er lijsten woorden die een specifiek concept representeren. Bijvoorbeeld in programmeertalen, zijn controlstatements een concept, namen van gegevenstypen een andere en ingebouwde functies van de taal een derde. Het accentueringssysteem voor syntaxis van &kappname; kan zulke lijsten gebruiken om woorden in de tekst te detecteren en te markeren om concepten te accentueren van de tekstformaten.

#### Standaard stijlen

Als u in &kappname; een C++ bronbestand, een &Java; bronbestand en een HTML document opent, dan zult u zien dat zelfs wanneer de formaten verschillend zijn en dus verschillende woorden voor een speciale behandeling worden gekozen, de gebruikte kleuren hetzelfde zijn. Dit komt omdat &kappname; een voorgedefinieerde lijst met standaard stijlen heeft die worden gebruikt bij de individuele definities van syntaxis.

Dit maakt het gemakkelijk om gelijkvormige concepten in verschillende tekstformaten te herkennen. Bijvoorbeeld: commentaar is in bijna elk programma, script of markup-language aanwezig en wanneer ze in alle talen op dezelfde manier worden weergegeven, dan hoeft u niet meer na te denken om ze in de tekst te herkennen.

Alle stijlen in een syntaxisdefinitie gebruiken een van de standaard stijlen. Een paar syntaxisdefinities gebruiken meer stijlen dan er standaarden zijn, dus als u een format vaak gebruikt kan het het waard zijn om de instellingendialoog te starten om te zien of sommige concepten dezelfde stijl gebruiken. Er is bijvoorbeeld slechts één standaard stijl voor tekenreeksen, maar de Perl programmeertaal werkt met twee typen tekenreeksen, u kunt het accentueren verbeteren door ze enigszins verschillend in te stellen. Alle beschikbare standaard stijlen zullen later worden verklaard.

### Het &XML;-formaat voor definitie van accentuering

#### Overzicht

Deze sectie is een overzicht van het formaat van 'Highlight Definition &XML;'. Het zal de hoofdcomponenten, hun betekenis en gebruik beschrijven op basis van een klein voorbeeld. De volgende sectie zal in detail de accentueringdetectieregels uitleggen.

De formele definitie, ook bekend als de XSD wordt opgeslagen in het bestand `language.xsd` die op uw systeem geïnstalleerd zou moeten zijn in de map `$`XDG_DATA_DIRS`/katepart5/syntax`. Waarin `XDG_DATA_DIRS` typisch expandeert tot `/usr/share`.

#### Hoofdsecties van bestanden voor accentueringsdefinities van &kappname;

Een bestand voor accentuering bevat een kop die de XML-versie instelt:

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

De basis van het definitiebestand is het element `language`. Beschikbare attributen zijn:

- Vereiste attributen:

  `name` stelt de naam van de taal in. Het verschijnt nadien in de menu's en dialogen.

  `section` specificeert de categorie.

  `extensions` definieert bestandsextensies, zoals "*.cpp;*.h"

  Optionele attributen:

  `mimetype` associeert ket &MIME;-type van bestanden.

  `version` specificeert de huidige versie van het definitiebestand.

  `kateversion` specificeert de laatst ondersteunde versie van &kappname;.

  `casesensitive` definieert of de sleutelwoorden gevoelig zijn voor hoofd- en kleine letters.

  `priority` is nodig als een andere bestand met accentueringsdefinities dezelfde extensies gebruiken. De hogere prioriteit wint.

  `author` bevat de naam van de auteur en zijn/haar e-mailadres.

  `license` bevat de licentie, gewoonlijk LGPL, Artistic, GPL of andere.

  `style` bevat de geleverde taal en wordt gebruikt door de indenteerders voor het attribuut `required-syntax-style`.

  `hidden` definieert of de naam moet verschijnen in de menu's van &kappname;.

  De volgende regel kan er als volgt uitzien:

      <language name="C++" version="1.00" kateversion="2.4" section="Sources" extensions="*.cpp;*.h" />

Vervolgens komt het element `highlighting`, die het optionele element `list` bevat en de vereiste elementen `contexts` en `itemDatas`.

- Elementen `list` bevatten een lijst met sleutelwoorden. In dit geval zijn de sleutelwoorden class en const. U mag zoveel elementen 'list' toevoegen als nodig is.

  Het element `contexts` bevat alle contexten. De eerste context is per definitie het begin van de accentuering. Er zijn twee regels in de context Normal Text, die overeenkomt met de lijst sleutelwoorden met de naam somename en een regel die een aanhalingsteken detecteert en de context om schakelt naar String. Om meer over regels te leren, leest u het volgende hoofdstuk.

  Het derde deel is het element `itemDatas`. Het bevat alle kleur- en lettertypestijlen nodig voor de contexten en regels. In dit voorbeeld worden `itemData` Normal Text, String en Keyword gebruikt.

      <highlighting>
          <list name="somename">
            <item> class </item>
            <item> const </item>
          </list>
          <contexts>
            <context attribute="Normal Text" lineEndContext="#pop" name="Normal Text" >
              <keyword attribute="Keyword" context="#stay" String="somename" />
              <DetectChar attribute="String" context="string" char="&quot;" />
            </context>
            <context attribute="String" lineEndContext="#stay" name="string" >
              <DetectChar attribute="String" context="#pop" char="&quot;" />
            </context>
          </contexts>
          <itemDatas>
            <itemData name="Normal Text" defStyleNum="dsNormal" />
            <itemData name="Keyword" defStyleNum="dsKeyword" />
            <itemData name="String" defStyleNum="dsString" />
          </itemDatas>
        </highlighting>

Het laatste deel van een accentueringsdefinitie is de optionele sectie `general`. Het mag informatie over sleutelwoorden, vouwen van code, commentaar en inspringen bevatten.

- De sectie `comment` definieert met welke tekenreeks een enkele regel commentaar wordt aangegeven. U kunt ook commentaar op meerdere regels definiëren met multiLine met het additionele attribuut end. Dit wordt gebruikt als de gebruiker op de bijbehorende sneltoets voor comment/uncomment drukt.

  De sectie `keywords` definieert of lijsten met sleutelwoorden onderscheid maken tussen hoofd- en kleine letters. Andere attributen zullen later worden verklaard.

      <general>
          <comments>
            <comment name="singleLine" start="#"/>
          </comments>
          <keywords casesensitive="1"/>
        </general>
      </language>

#### De secties in detail

Dit deel zal alle beschikbare attributen voor contexten beschrijven, itemDatas, sleutelwoorden, commentaar, code opvouwen en inspringen.

Het element `context` behoort tot de groep `contexts`. Een context zelf definieert context specifieke regels zoals wat zou moeten gebeuren als het systeem voor accentuering het eind van een regel bereikt. Beschikbare attributen zijn:

- `name` geeft de contextnaam aan. Regels zullen deze naam gebruiken om de context te specificeren om om te schakelen als de regel overeenkomt.

  `lineEndContext` definieert de context waarnaar het systeem voor accentuering omschakelt als het einde van een regel wordt bereikt. Dit kan of de naam van een andere context zijn, `#stay` om de context niet om te schakelen (⪚. niets doen) of `#pop` wat de oorzaak is van het verlaten van deze context. Het is mogelijk om bijvoorbeeld `#pop#pop#pop` te gebruiken om drie keer te poppen of zelfs `#pop#pop!AndereContext` om twee keer te poppen en om te schakelen naar de context genaamd `AndereContext`.

  `lineEmptyContext` definieert de context als een lege regel wordt bereikt. Standaard: #stay.

  `fallthrough` definieert of het systeem voor accentuering omschakelt naar de context gespecificeerd in fallthroughContext als er geen regel overeenkomt. Standaard: false.

  `fallthroughContext` specificeert de volgende context als geen regel overeenkomt.

  `dynamic` indien true, dan herinnert de context tekenreeksen/plaatshouders opgeslagen door dynamische regels. Dit is bijvoorbeeld nodig voor HIER-documenten. Standaard: false.

Het element `itemData` is in de groep `itemDatas`. Het definieert de lettertypestijl en kleuren. Het is dus mogelijk om uw eigen stijlen en kleuren te definiëren. Wij bevelen echter aan om, indien mogelijk, bij de standaard stijlen te blijven zodat de gebruiker altijd dezelfde zal zien in verschillende talen. Soms is er echter geen andere manier en is het noodzakelijk de kleur- en lettertypeattributen te wijzigen. De attributen naam en defStyleNum zijn vereist, de anderen zijn optioneel. Beschikbare attributen zijn:

- `name` stelt de naam van het itemData in. Contexten en regels zullen deze naam in hun attribuut attribute gebruiken om naar een itemData te verwijzen.

  `defStyleNum` definieert welke standaard stijl te gebruiken. Beschikbare standaard stijlen worden later in detail verklaard.

  `color` definieert een kleur. Geldige formaten zijn '#rrggbb' of '#rgb'.

  `selColor` definieert de selectiekleur.

  `italic` indien true, de tekst zal cursief worden.

  `bold` indien true, de tekst zal vet worden.

  `underline` indien true, de tekst zal onderstreept worden.

  `strikeout` indien true, door de tekst zal een streep worden gezet.

  `spellChecking` indien true, de tekst zal gecontroleerd worden op spelling.

Het element `keywords` in de groep `general` definieert sleutelwoordeigenschappen. Beschikbare attributen zijn:

- `casesensitive` mag true of false zijn. Indien true, worden alle sleutelwoorden met onderscheid tussen hoofd- en kleine letters met elkaar vergeleken

  `weakDeliminator` is een lijst met tekens die niet als scheiding tussen woorden werken. Bijvoorbeeld: de punt `'.'` is een scheider van woorden. Als een sleutelwoord in een `list` een punt bevat, dan zal die alleen overeenkomen als u de punt als een zwak scheidingsteken specificeert.

  `additionalDeliminator` definieert extra scheidingstekens.

  `wordWrapDeliminator` definieert tekens waarna een regel mag afbreken.

  Standaard scheidingstekens en regelafbreektekens zijn de tekens `.():!+,-<=>%&*/;?[]^{|}~\`, spatie (`' '`) en tab (`'\t'`).

Het element `comment` in de groep `comments` definieert eigenschappen van commentaar die gebruikt worden voor Hulpmiddelen Commentaar en Hulpmiddelen Commentaar verwijderen. Beschikbare attributen zijn:

- `name` is either singleLine or multiLine. If you choose multiLine the attributes end and region are required.

  `start` definieert de gebruikte tekenreeks om commentaar te laten beginnen. In C++ zou dit "/*" zijn.

  `end` definieert de gebruikte tekenreeks om commentaar te laten eindigen. In C++ zou dit "*/" zijn.

  `region` moet de naam van het opvouwbare multiregel commentaar. U hebt beginRegion="Comment" ... endRegion="Comment" in uw regels, u zou region="Comment" moeten gebruiken. Op deze manier werkt verwijderen zelfs als u niet alle tekst van het multiregel commentaar selecteert. De cursor hoeft alleen in het multiregel commentaar te staan.

Het element `folding` in de groep `general` definieert de eigenschappen van het invouwen van broncode. Beschikbare attributen zijn:

- De markeringen voor code opvouwen, als `indentationsensitive` true is, zullen worden toegevoegd gebaseerd op inspringen, zoals in de scripttaal Python. Het is gewoonlijk niet nodig dit in te stellen omdat de standaard false is.

Het element `indentation` in de groep `general` definieert welke inspringing gebruikt zal worden. We bevelen ten zeerste aan om dit element over te slaan, omdat de inspringing gewoonlijk ingesteld zal worden door ofwel een Bestandstype of door een modusregel toe te voegen aan het tekstbestand. Als u toch een inspringing definieert, forceert u een specifieke inspringing op de gebruiker, die hij helemaal niet wil. Beschikbare attributen zijn:

- `mode` is de naam van de inspringing. Beschikbare inspringingen op dit moment zijn: normal, cstyle, haskell, lilypond, lisp, python, ruby en xml.

#### Beschikbare standaard stijlen

Standaard stijlen zijn al verklaard, als een korte samenvatting: Standaard stijlen zijn voorgedefinieerde lettertypen- en kleurstijlen.

Algemene standaard stijlen:

- `dsNormal`, wanneer geen speciale accentuering is vereist.

  `dsKeyword`, ingebouwde sleutelwoorden van taal.

  `dsFunction`, functie-aanroepen en definities.

  `dsVariable`, indien van toepassing: namen van variabelen (bijv. $eenVar in PHP/Perl).

  `dsControlFlow`, sleutelwoorden voor flowcontrol zoals if, else, switch, break, return, yield, ...

  `dsOperator`, operatoren zoals + - * / :: < >

  `dsFunction`, ingebouwde functies, klassen en objecten.

  `dsExtension`, algemene extensies, zoals Qt klassen en functies/macro's in C++ en Python.

  `dsPreprocessor`, preprocessor statements of macro-definities.

  `dsAttribute`, annotaties zoals @override en __declspec(...).

Standaard stijlen gerelateerd aan tekenreeksen

- `dsChar`, enkele tekens, zoals 'x'.

  `dsSpecialChar`, tekens met een speciale betekenis in tekenreeksen zoals escapes, substituties of regex-operatoren.

  `dsString`, tekenreeksen zoals "hello world".

  `dsVerbatimString`, letterlijke of raw-tekenreeksen zoals 'raw \backlash' in Perl, CoffeeScript en shells, evenals r'\raw' in Python.

  `dsSpecialString`, SQL, regexes, HERE-docs, LaTeX math mode, ...

  `dsImport`, import, include, require van modulen.

Standaard stijlen gerelateerd aan getallen:

- `dsDataType`, ingebouwde typen gegevens zoals int, void, u64.

  `dsDecVal`, decimale waarden.

  `dsBaseN`, waarden met een andere basis dan 10.

  `dsFloat`, drijvende-komma waarden.

  `dsConstant`, ingebouwde en gebruikergedefineerde constanten zoals pi.

Standaard stijlen gerelateerd aan commentaar en documentatie:

- `dsComment`, commentaar.

  `dsDocumentation`, /** Documentatie commentaar */ of """docstrings""".

  `dsAnnotation`, documentatiecommando's zoals @param, @brief.

  `dsCommentVar`, de in bovenstaande commando's gebruikte namen van variabelen, zoals "foobar" in @param foobar.

  `dsRegionMarker`, gebiedsmarkeringen zoals//BEGIN, //END in commentaar.

Andere standaard stijlen:

- `dsInformation`, notities en tips zoals @note in doxygen.

  `dsWarning`, waarschuwingen zoals @warning in doxygen.

  `dsAlert`, speciale woorden zoals TODO, FIXME, XXXX.

  `dsError`, accentuering van fouten en foute syntaxis.

  `dsOthers`, wanneer niets anders past.

### Detectieregels accentueren

Deze paragraaf beschrijft de syntaxis van detectieregels.

Elke regel kan nul of meer tekens aan het begin van de tekenreeks bevatten, waartegen ze worden getest. Als de regel overeenkomt worden de overeenkomstige tekens toegekend aan de stijl of attribuut gedefinieerd door de regel en een regel kan vragen de huidige context om te schakelen.

Een regel ziet er als volgt uit:

    <RuleName attribute="(identifier)" context="(identifier)" [regelspecifieke attributen] />

Het attribute identificeert de te gebruiken stijl voor overeenkomende tekens bij naam en de context identificeert de vanaf hier te gebruiken context.

De context kan worden geïdentificeerd door:

- Een identifier, wat de naam is van de andere context.

- Een opdracht die de engine vertelt om in de huidige context te blijven (`#stay`) of terug te gaan naar een eerdere context met in de tekenreeks (`#pop`).

  Om meer stappen terug te gaan kan het #pop commando worden herhaald: `#pop#pop#pop`

- Een order gevolgd door een uitroepteken (!) en een identifier, die er voor zorgt dat de engine eerst de order volgt en dan omschakelt naar de andere context, bijv. `#pop#pop!AndereContext`.

Sommige regels kunnen dochterregels hebben die dan alleen worden geëvalueerd als de ouderregel overeenkomt. De gehele overeenkomende tekenreeks zal het attribuut worden gegeven die is gedefinieerd door de ouderregel. Een regel met dochterregels ziet er als volgt uit:

    <RuleName (attributen)>
      <ChildRuleName (attributen) />
      ...
    </RuleName>

Specifieke attributen van regels variëren en zijn beschreven in de volgende secties.

### Gezamenlijke attributen

Alle regels hebben de volgende gezamenlijke attributen en zijn beschikbaar wanneer `(common attributes)` verschijnt. attribute en context zijn vereiste attributen, alle andere zijn optioneel.

- attribute: Een attribuut komt overeen met een gedefinieerd itemData.

- context: Specificeer de context waarnaar het accentueringssysteem omschakelt als de regel overeenkomt.

- beginRegion: Start een invouwblok voor code. Standaard: niet ingesteld.

- endRegion: Sluit een invouwblok voor code. Standaard: niet ingesteld.

- lookAhead: Indien true, zal het accentueringssysteem niet de overeenkomende lengte verwerken. Standaard: false.

- firstNonSpace: Komt alleen overeen als de tekenreeks de eerste niet-witruimte in de regel. Standaard: false.

- column: Komt alleen overeen als de kolom overeenkomt. Standaard: niet ingesteld.

### Dynamische regels

Sommige regels staan het optionele attribuut `dynamic` toe van het type boolean dat standaard de waarde false heeft. Als dynamic true is kan een regel plaatshouders bevatten die de tekst representeren die overeenkomt met een reguliere expressie die schakelt naar de huidige context in zijn attributen `tekenreeks` of `teken`. In een `tekenreeks`wordt de plaatshouder `%N` (waar N is a getal is) vervangen door de overeenkomstige vangst `N` uit de aanroepende reguliere expressie. In een `teken` moet de plaatshouder een getal `N` zijn en het zal worden vervangen door het eerste teken van de overeenkomstige vangst `N` uit de aanroepende reguliere expressie. Wanneer een regel dit attribuut toestaat zal het een (dynamic) bevatten.

- dynamic: kan (true|false) zijn.

#### De regels in detail

DetectChar

- Detecteert een enkele specifiek teken. Gewoonlijk gebruikt, bijvoorbeeld om het einde van een tekenreeks tussen accenten of aanhalingstekens.

      <DetectChar char="(teken)" (common attributes) (dynamic) />

  Het attribuut `char` definieert het teken dat moet overeenkomen.

Detect2Chars

- Detecteert twee specifieke tekens in een gedefinieerde volgorde.

      <Detect2Chars char="(teken)" char1="(teken)" (common attributes) (dynamic) />

  Het attribuut `char` definieert het eerste teken dat moet overeenkomen, `char1` the tweede.

AnyChar

- Detecteer één teken van een set van gespecificeerde tekens.

      <AnyChar String="(tekenreeks)" (common attributes) />

  Het attribuut `String` definieert de set tekens.

StringDetect

- Detecteert een exacte tekenreeks.

      <StringDetect String="(tekenreeks)" [insensitive="true|false"] (common attributes) (dynamic) />

  Het attribuut `String` definieert de overeen te komen tekenreeks. Het attribuut `insensitive` is standaard false en wordt doorgegeven aan de vergelijkingsfunctie van de tekenreeks. Als de waarde true is wordt 'insensitive' vergelijking gebruikt.

WordDetect

- Detecteert een exacte tekenreeks maar vereist extra woordgrenzen zoals een punt `'.'` of witruimte aan het begin en eind van het woord. Denk aan `\b<tekenreeks>\b` in termen van een reguliere expressie, het is echter sneller dan de regel `RegExpr`.

      <WordDetect String="(tekenreeks)" [insensitive="true|false"] (common attributes) (dynamic) />

  Het attribuut `String` definieert de overeen te komen tekenreeks. Het attribuut `insensitive` is standaard false en wordt doorgegeven aan de vergelijkingsfunctie van de tekenreeks. Als de waarde true is wordt 'insensitive' vergelijking gebruikt.

  Sinds: Kate 3.5 (KDE 4.5)

RegExpr

- Komt overeen met een reguliere expressie.

      <RegExpr String="(tekenreeks)" [insensitive="true|false"] [minimal="true|false"] (common attributes) (dynamic) />

  Het attribuut `String` definieert de reguliere expressie.

  `insensitive` is standaard false en wordt doorgegeven aan de engine voor de reguliere expressie.

  `minimal` is standaard false en wordt doorgegeven aan de engine voor de reguliere expressie.

  Omdat de regels altijd vergeleken worden met het begin van de huidige tekenreeks, zal een reguliere expressie die begint met een dakje (`^`) aangeven dat de regel alleen overeen moet komen met het begin van een regel.

  Zie Reguliere expressies voor meer informatie hierover.

trefwoord

- Detecteert een sleutelwoord uit een gespecificeerde lijst.

      <keyword String="(lijstnaam)" (common attributes) />

  Het attribuut `String` identificeert de lijst met sleutelwoorden met een naam. Een lijst met die naam moet bestaan.

  Het systeem voor accentuering bewerkt sleutelwoordregels op een zeer geoptimaliseerde manier. Dit maakt het absoluut noodzakelijk dat elk te vinden sleutelwoord omgeven wordt door gedefinieerde scheidingstekens, ofwel impliciet (de standaard scheidingstekens) of expliciet gespecificeerd binnen de eigenschap additionalDeliminator van de sleutelwoord-tag.

  Als een te vinden sleutelwoord een scheidingsteken moet bevatten, dan moet dit teken toegevoegd worden aan de eigenschap weakDeliminator van de sleutelwoord-tag. Dit teken zal dan zijn eigenschap scheidingsteken in alle sleutelwoord-regels verliezen.

Int

- Detecteert een geheel getal.

      <Int (common attributes) (dynamic) />

  Deze regel heeft geen specifieke attributen. Dochterregels worden typisch gebruikt om combinaties met `L` en `U` na het getal te detecteren, die het type geheel getal in programmacode aangeeft. Alle dochterregels zijn toegestaan als dochterregels, hoewel de DTD alleen de dochterregel `StringDetect` toestaat.

  Het volgende voorbeeld laat overeenkomst zien met gehele getallen gevolgd door het teken 'L'.

      <Int attribute="Decimal" context="#stay" >
        <StringDetect attribute="Decimal" context="#stay" String="L" insensitive="true"/>
      </Int>

Zwevend

- Een drijvende kommagetal detecteren.

      <Drijvende komma (algemene attributen) />

  Deze regel heeft geen specifieke attributen. `AnyChar` is toegestaan als een dochterregel en wordt typisch gebruikt om combinaties te detecteren, zie de regel `Int` als referentie.

HlCOct

- Detecteert de representatie van een octaal puntgetal.

      <HlCOct (common attributes) />

  Deze regel heeft geen specifieke attributen.

HlCHex

- Detecteert de representatie van een hexadecimaal getal.

      <HlCHex (common attributes) />

  Deze regel heeft geen specifieke attributen.

HlCStringChar

- Detecteer een escaped teken.

      <HlCStringChar (common attributes) />

  Deze regel heeft geen specifieke attributen.

  Komt overeen met de letterlijke representatie van tekens, gewoonlijk gebruikt in programmacode, bijvoorbeeld `\n` (nieuwe-regel) of `\t` (TAB).

  De volgende tekens zullen overeenkomen als ze volgen op een backslash (`\`): `abefnrtv"'?\`. Bovendien escaped hexadecimale getallen zoals bijvoorbeeld `\xff` en escaped octale getallen, zoals bijvoorbeeld `\033` zullen overeenkomen.

HlCChar

- Detecteer een C-teken.

      <HlCChar (gezamenlijke attributen) />

  Deze regel heeft geen specifieke attributen.

  Komt overeen met een C-teken tussen accenten (Bijvoorbeeld: `'c'`). De accenten kunnen een eenvoudig teken zijn of een escaped teken. Zie HlCStringChar voor overeenkomende reeksen van escaped tekens.

RangeDetect

- Detecteert een tekenreeks met gedefinieerde begin- en eindtekens.

      <RangeDetect char="(teken)"  char1="(teken)" (gezamenlijke attributen) />

  `char` defines the character starting the range, `char1` the character ending the range.

  Bruikbaar om bijvoorbeeld kleine tekenreeksen of zoiets te detecteren, maar merk op dat de accentiëringsengine werkt op één regel tegelijk, hierdoor zullen tekenreeksen over meerdere regels niet gevonden worden.

LineContinue

- Komt overeen met een gespecificeerd teken aan het eind van een regel.

      <LineContinue (gezamenlijke attributen) [char="\"] />

  `char` optioneel teken dat moet overeenkomen, standaard is de backslash (`'\'`). Nieuw sinds KDE 4.13.

  Deze regel is bruikbaar voor het omschakelen van context aan het einde van een regel. Dit is bijvoorbeeld nodig in C/C++ om macro's of tekenreeksen door te laten lopen.

IncludeRules

- Voeg regels in uit een ander context- of taalbestand.

      <IncludeRules context="contextlink" [includeAttrib="true|false"] />

  Het attribuut `context` definieert welke context in te voegen.

  Als het een eenvoudige tekenreeks is dan zijn alle gedefinieerde regels in de huidige context ingevoegd, bijvoorbeeld:

      <IncludeRules context="anotherContext" />

  Als de tekenreeks `##` bevat zal het accentueringssysteem zoeken naar een context uit een andere taaldefinitie met de gegeven naam, bijvoorbeeld

      <IncludeRules context="String##C++" />

  zou de context String uit de accentueringsdefinitie van C++ invoegen.

  Als attribuut `includeAttrib` true is, dan wijzigt het doelattribuut naar die van de bron. Dit is vereist om bijvoorbeeld het aanbrengen van commentaar te laten werken als tekst die overeenkomt met de ingevoegde context een verschillende accentuering is van de host-context.

DetectSpaces

- Detecteert witruimte.

      <DetectSpaces (gezamenlijke attributen) />

  Deze regel heeft geen specifieke attributen.

  Gebruik deze regel als u weet dat er verschillende witruimtes aankomen, bijvoorbeeld aan het begin van inspringende regels. Deze regel slaat alle witruimte in een keer over, in plaats van testen met meerdere regels en een voor een overslaan vanwege geen overeenkomst.

DetectIdentifier

- Detecteer tekenreeksen voor een identifier (als een reguliere expressie: [a-zA-Z_][a-zA-Z0-9_]*).

      <DetectIdentifier (gezamenlijke attributen) />

  Deze regel heeft geen specifieke attributen.

  Gebruik deze regel om een reeks woordtekens in een keer over te slaan, in plaats van deze te testen met meerdere regels en ze een voor een over te slaan omdat er geen overeenkomst is.

#### Tips & trucs

Als u hebt begrepen hoe het omschakelen van context werkt zal het gemakkelijk zijn om definities voor accentuering te schrijven. Hoewel u zeer zorgvuldig moet controleren welke regel u kiest in welke situatie. Reguliere expressies zijn erg krachtig, maar ze zijn langzaam vergeleken met de andere regels. Dus zou u de volgende tips nog eens moeten bekijken.

- Als u alleen twee tekens wilt laten overeenkomen gebruik dan `Detect2Chars` in plaats van `StringDetect`. Hetzelfde is van toepassing op `DetectChar`.

- Reguliere expressies zijn gemakkelijk te gebruiken maar vaak is er een andere veel snellere manier om hetzelfde resultaat te behalen. U wilt alleen een overeenkomst vinden met het teken `'#'` als het het eerste teken is in de regel. Een oplossing gebaseerd op een reguliere expressie zou er zo uit zien:

      <RegExpr attribute="Macro" context="macro" String="^\s*#" />

  . U kunt hetzelfde veel sneller bereiken door te gebruiken:

      <DetectChar attribute="Macro" context="macro" char="#" firstNonSpace="true" />

  . Als u de reguliere expressie `'^#'` wilt laten vereen komen dan kunt u nog steeds `DetectChar` gebruiken met het attribuut `column="0"`. Het attribuut `column` telt tekens zodat een tab nog één teken is.

- U kunt van contexts wisselen zonder tekens te bewerken. Neem aan dat u van context wilt wisselen wanneer u de tekenreeks `*/` tegenkomt, maar u moet die tekenreeks in de volgende context bewerken. De onderstaande regel zal overeenkomen en het attribuut `lookAhead` zal de overeenkomende tekenreeks voor accentuering bewaren voor de volgende context.

      <Detect2Chars attribute="Comment" context="#pop" char="*" char1="/" lookAhead="true" />

- Gebruik `DetectSpaces` als u weet dat er veel witruimtes zijn.

- Gebruik `DetectIdentifier` in plaats van de reguliere expressie `'[a-zA-Z_]\w*'`.

- Gebruik standaard stijlen wanneer dat kan. Op deze manier vindt de gebruiker een bekende omgeving.

- Kijk in andere XML-bestanden om te zien hoe andere mensen ingewikkelde regels implementeren.

- U kunt elk XML-bestand valideren door het commando `xmllint --schema language.xsd mySyntax.xml` te gebruiken.

- Als u complexe reguliere expressies erg vaak gebruikt dan kunt u ENTITIES gebruiken. Voorbeeld:

      <?xml version="1.0" encoding="UTF-8"?>
      <!DOCTYPE language SYSTEM "language.dtd"
      [
              <!ENTITY myref    "[A-Za-z_:][\w.:_-]*">
      ]>

  Nu kunt u &myref; gebruiken in plaats van de reguliere expressie.

## Scripting met JavaScript

De editor-component van &kappname; is eenvoudig uit te breiden met scripts. De scripttaal is ECMAScript (breed bekend als JavaScript). &kappname; ondersteunt twee soorten scripts: inspringen en commandoregelscripts.

### Inspringscripts

Inspringscripts - ook genoemd indenteerders - laten de broncode inspringen bij het typen van tekst. Na het indrukken van de toets Enter zal het inspringniveau vaak toenemen.

De volgende secties beschrijven stap voor stap hoe het skelet voor een eenvoudige indenteerder te maken. Als eerste stap, maak een nieuw bestand `*.js` aan, ⪚ met de naam `javascript.js` in de lokale thuismap `$`XDG_DATA_HOME`/katepart5/script/indentation`. Waarin de omgevingsvariabele `XDG_DATA_HOME` typisch expandeert tot ofwel `~/.local` of `~/.local/share`.

#### De kop van het inspringscript

De kop van het bestand `javascript.js` is ingebed als JSON aan het begin van het document als volgt:

    var kate-script = {
     * "name": JavaScript
     * "author": Voorbeeldnaam <voorbeeld.naam@een.adres.org>,
     * "license": "BSD License"
     * "revision": 1,
     * "kate-version": "5.1",
     * "required-syntax-style": javascript,
     * "indent-languages": ["javascript"],
     * "priority": 0,
     *}; // kate-script-header, moet aan het begin van het bestand staan zonder commentaar

Elk item wordt nu in detail uitgelegd:

- `name` [vereist]: Dit is de naam van de indenteerder die in het menu Hulpmiddelen Inspringen verschijnt en in de configuratiedialoog.

- `author` [optioneel]: De naam van de auteur en contactinformatie.

- `license` [optioneel]: Korte vorm van de licentie, zoals BSD License of LGPLv3.

- `revision` [vereist]: De revisie van het script. Dit getal moet verhoogd worden wanneer het script wordt gewijzigd.

- `kate-version` [required]: Minimaal vereiste versie van &kappname;.

- `required-syntax-style` [optioneel]: De vereiste stijl voor de syntaxis, die overeenkomt met de gespecificeerde `style` in bestanden voor accentuering van syntaxis. Dit is belangrijk voor indenteerders die vertrouwen op specifieke informatie voor accentuering in het document. Als een vereiste syntaxisstijl is gespecificeerd, zal de indenteerder alleen beschikbaar zijn wanneer het juiste programma voor accentuering actief is. Dit voorkomt ongedefinieerd gedrag veroorzaakt door de indenteerder te gebruiken zonder het verwachte schema voor accentuering. De Ruby indenteerder, bijvoorbeeld, maakt hier gebruik van in de bestanden `ruby.js` en `ruby.xml`.

- `indent-languages` [optioneel]: JSON array van syntaxis stijlen die de indenteerder correct kan laten inspringen, ⪚: `["c++", "java"]`.

- `priority` [optioneel]: Als verschillende indenteerders geschikt zij voor een bepaald bestand om te accentueren, dan bepaalt de prioriteit welke indenteerder als standaard wordt gekozen.

#### De broncode van de indenteerder

Nadat de header is gespecificeerd, legt deze sectie uit hoe het script voor inspringen zelf werkt. Het basis sjabloon van de inhoud ziet er uit als volgt:

    // vereiste js-bibliotheken van katepart, bijv. range.js als u Range gebruikt
    require ("range.js");
    triggerCharacters = "{}/:;";
    function indent(line, indentWidth, ch)
    {
        // aangeroepen voor elk teken nieuwe-regel (ch == '\n') en alle tekens gespecificeerd in
        // de globale variabele triggerCharacters. Bij het aanroepen van HulpmiddelenUitlijnen
        // is de variabele ch leeg, i.e. ch == ''.
        //
        // zie ook: Scripting API
        return -2;
    }

De functie `indent()` heeft drie parameters:

- `line`: de regel die moet inspringen

- `indentWidth`: de inspringbreedte in aantal spaties

- `ch`: of een teken nieuwe-regel (`ch == '\n'`), het activeringsteken gespecificeerd in `triggerCharacters` of leeg als de gebruiker de actie Hulpmiddelen Uitlijnen heeft gestart.

De terugkeerwaarde van de functie `indent()` specificeert hoe de regel zal worden ingesprongen. Als de terugkeerwaarde een eenvoudig geheel getal is, wordt deze geïnterpreteerd als volgt:

- terugkeerwaarde `-2`: niets doen

- terugkeerwaarde `-1`: behoudthet inspringen (zoekt naar voorgaande niet-blanko regel)

- terugkeerwaarde `0`: getallen >= 0 specificeer de insringdiepte in spaties

Alternatief, een reeks van twee elementen kan worden teruggegeven:

- `geef [ indent, align ] terug;`

In dit geval is het eerste element de inspringdiepte zoals hierboven met dezelfde betekenis van de speciale waarden. Het tweede element is een absolute waarde die een kolom aangeeft voor uitlijning. Als deze waarde groter is dan de inspringwaarde, dan is het verschil een aantal spaties dat na het inspringen van de eerste parameter moet worden toegevoegd. Anders wordt het tweede getal genegeerd. Tabs en spaties voor inspringen gebruiken wordt vaak gemengde modus genoemd.

beschouw het volgende voorbeeld: Neem aan dat tabs worden gebruikt voor inspringen en tabbreedte is ingesteld op 4. <tab> vertegenwoordigt hier een tab-teken en '.' een spatie:

    1: <tab><tab>foobar("hello",
    2: <tab><tab>......."world");

Bij inspringen van regel 2 zal de functie `indent()` [8, 15] als terugkeerwaarde geven. Als resultaat worden hier twee tabs ingevoegd om in te springen tot kolom 8 en worden 7 spaties toegevoegd om de tweede parameter uit te lijnen onder de eerste, zodat het uitgelijnd blijft als het bestand wordt bekeken met een andere tabbreedte.

Een standaard &kde; installatie levert bij &kappname; verschillende indenteerders. De overeenkomstige JavaScript broncode kan worden gevonden in `$`XDG_DATA_DIRS`/katepart5/script/indentation`.

Ontwikkeling van een indenteerder vereist herladen van de scripts om te zien of de wijzigingen zich netjes gedragen. In plaats van het opnieuw opstarten van de toepassing, schakel eenvoudig om naar de commandoregel en start het commando `reload-scripts`.

Als u bruikbare scripts ontwikkeld overweeg dan deze aan het &kappname;-project bij te dragen door kontact op te nemen via de e-maillijst.

### Commandoregelscripts

Omdat het moeilijk is om aan de noden van iedereen te voldoen, ondersteunt &kappname; kleine hulpmiddelen voor snelle tekstmanipulatie via de ingebouwde commandoregel. Het commando `sort` is bijvoorbeeld geïmplementeerd als een script. Deze sectie legt uit hoe `*.js` bestanden aan te maken om &kappname; uit te breiden met willekeurige hulpscripts.

Commandoregelscripts staan in dezelfde map als inspringscripts. Dus als eerste stap maakt u een nieuw `*.js` bestand aan genaamd `myutils.js` in de lokale map `$`XDG_DATA_HOME`/katepart5/script/commands`. De omgevingsvariabele `XDG_DATA_HOME` daarin expandeert typisch tot ofwel `~/.local` of `~/.local/share`.

#### De kop van het commandoregelscript

De header van elke commandoregelscript is ingebed in JSON aan het begin van het script als volgt:

    var katescript = {
        "author": "Voorbeeldnaam <voorbeeld.naam@een.adres.org>",
        "license": "LGPLv2+",
        "revision": 1,
        "kate-version": "5.1",
        "functions": ["sort", "moveLinesDown"],
        "actions": [
            {   "function": "sort",
                "name": "Sort Selected Text",
                "category": "Editing",
                "interactive": "false"
            },
            {   "function": "moveLinesDown",
                "name": "Move Lines Down",
                "category": "Editing",
                "shortcut": "Ctrl+Shift+Down",
                "interactive": "false"
            }
        ]
    }; // kate-script-header, moet zich bevinden aan het begin van het bestand zonder commentaar

Elk item wordt nu in detail uitgelegd:

- `author` [optioneel]: De naam van de auteur en contactinformatie.

- `license` [optioneel]: Korte vorm van de licentie, zoals BSD licentie of LGPLv2.

- `revision` [vereist]: De revisie van het script. Dit getal moet verhoogd worden wanneer het script wordt gewijzigd.

- `kate-version` [required]: Minimaal vereiste versie van &kappname;.

- `functions` [vereist]: JSON-array met commando's in het script.

- `actions` [optioneel]: JSON Array van JSON objecten die de acties definiëren die verschijnen in het menu van de toepassing. Gedetailleerde informatie wordt in de sectie Koppelen van sneltoetsen.

Omdat de waarde van `functions` een JSON array is, is een enkel script in staat een willekeurig aantal commandoregels te bevatten. Elke functie is beschikbaar via ingebouwde commandoregel van &kappname;.

#### De broncode van het script

Alle in de kop gespecificeerde functies moeten worden geïmplementeerd in het script. Het script-bestand uit het bovenstaande voorbeeld moet de twee functies `sort` en `moveLinesDown` implementeren. Alle functies hebben de volgende syntaxis:

    // vereiste js-bibliotheken van katepart, bijv. range.js als u Range gebruikt
    require ("range.js");

    function <naam>(arg1, arg2, ...)
    {
        // ... implementatie, zie ook: Scripting API
    }

De argumenten in de commandoregel worden doorgegeven naar de functie als `arg1`, `arg2`, etc. Om documentatie voor elk commando te leveren, implementeert u eenvoudig de functie '`help`' als volgt:

    function help(cmd)
    {
        if (cmd == "sort") {
            return i18n("Sort the selected text.");
        } else if (cmd == "...") {
            // ...
        }
    }

uitvoeren van `help sort` in de commandoregel roept deze help-functie op met het argument `cmd` ingesteld op het gegeven commando, &ie; `cmd == "sort"`. &kappname; laat dan de teruggeleverde tekst zien als documentatie voor de gebruiker. Zorg er voor dat de tekenreeksen vertaald zijn.

Ontwikkeling van een commandoregelscript vereist herladen van de scripts om te zien of de wijzigingen zich netjes gedragen. In plaats van het opnieuw opstarten van de toepassing, schakel eenvoudig om naar de commandoregel en start het commando `reload-scripts`.

##### Koppelen van sneltoetsen

Om de scripts toegankelijk te maken in het menu van de toepassing en sneltoetsen toe te kunnen, moet het script een juiste script-header leveren. In het bovenstaande voorbeeld, verschijnen beide functies `sort` en `moveLinesDown` in het menu vanwege het volgende deel in de script-header:

    var katescript = {
        ...
        "actions": [
            {   "function": "sort",
                "name": "Sort Selected Text",
                "icon": "",
                "category": "Editing",
                "interactive": "false"
            },
            {   "function": "moveLinesDown",
                "name": "Move Lines Down",
                "icon": "",
                "category": "Editing",
                "shortcut": "Ctrl+Shift+Down",
                "interactive": "false"
            }
        ]
    };

De velden voor een actie zijn als volgt:

- `function` [vereist]: De functie die zou moeten verschijnen in het menu Hulpmiddelen Scripts.

- `name` [vereist]: De tekst verschijnt het script-menu.

- `icon` [optioneel]: Het pictogram verschijnt naast de tekst in het menu. Alle pictogramnamen van &kde; kunnen hier worden gebruikt.

- `category` [optioneel]: Als een categorie wordt gespecificeerd, verschijnt het script in een submenu.

- `shortcut` [optioneel]: De hier gegeven sneltoets is de standaard sneltoets. Voorbeeld: `Ctrl+Alt+t`. Zie de Qt documentatie voor verdere details.

- `interactive` [optioneel]: Als het script invoer van de gebruiker in de commandoregel nodig heeft, zet dit dan op `true`.

Als u bruikbare scripts ontwikkeld overweeg dan deze aan het &kappname;-project bij te dragen door kontact op te nemen via de e-maillijst.

### API voor scripts

De API voor scripts hier aanwezig is beschikbaar voor alle scripts, ⪚ scripts voor inspringen en opdrachtregels. De klassen `Cursor` en `Range` worden geleverd door biblitheekbestanden in `$`XDG_DATA_DIRS`/katepart5/libraries`. Als u ze in uw script wilt gebruiken, wat nodig is om bepaalde `Document` of `View`-functies te gebruiken, voeg dan de benodigde bibliotheek in met:

    // vereiste js-bibliotheken van katepart, bijv. range.js als u Range gebruikt
    require ("range.js");

Om de standaard API voor scripting uit te breiden met uw eigen functies en prototypen, maak gewoon een nieuw bestand aan in de lokale configuratiemap van &kde; `$`XDG_DATA_HOME`/apps/katepart5/libraries` en voeg deze in in uw script met:

    require ("mijnscriptnaamhier.js");

Om bestaande prototypes zoals `Cursor` of `Reeks` uit te breiden, os de aanbevolen manier om niet de globale `*.js` bestanden te wijzigen. In plaats daarvan wijzigt u het prototype `Cursor` in JavaScript nadat `cursor.js` is ingevoegd in uw script via `require`.

#### Cursors en bereiken

Omdat &kappname; is een tekstbewerker is, is alles voor de API voor scripting, waar mogelijk, gebaseerd op cursors en reeksen. Een cursor is een eenvoudig een paar `(regel, kolom)` die een tekstpositie in het document weergeeft. Een reeks omspant tekst van een begincursorpositie tot een eincursorpositie. De API wordt in de volgende secties in detail uitgelegd.

##### Het prototype van cursor

    Cursor();

- Constructor. Levert een cursor terug op positie `(0, 0)`.

  Voorbeeld: `var cursor = new Cursor();`

    Cursor(int regel, int kolom);

- Constructor. Levert een cursor terug op positie (regel, kolom).

  Voorbeeld: `var cursor = new Cursor(3, 42);`

    Cursor(Cursor andere);

- Constructor kopiëren. Geeft een kopie van de cursor `andere`.

  Voorbeeld:`var copy = nieuwe cursor(andere);`

    Cursor Cursor.clone();

- Geeft een kloon van de cursor terug.

  Voorbeeld: `var clone = cursor.clone();`

    Cursor.setPosition(int regel, int kolom);

- Stel de cursorpositie in op `regel` en `kolom`.

  Sinds: &kde; 4.11

    bool Cursor.isValid();

- Controleert of de cursor geldig is. De cursor is ongeldig indien lijn en/of kolom ingesteld zijn op `-1`.

  Voorbeeld: `var valid = cursor.isValid();`

    Cursor Cursor.invalid();

- Geeft een nieuwe ongeldige cursor op locatie `(-1, -1)`.

  Voorbeeld:`var invalidCursor = cursor.invalid();`

    int Cursor.compareTo(Cursor andere);

- Vergelijkt deze cursor met de cursor `andere`. Geeft terug

  - `-1`, indien deze cursor zich bevindt voor de cursor `andere`,

  - `0`, indien beide cursors gelijk zijn

  - `+1`, als deze cursor gelokaliseerd is na de cursor `andere`.

    bool Cursor.equals(Cursor andere);

- Geeft `true` terug, als deze cursor en de cursor `andere` gelijk zijn, anders `false`.

    String Cursor.toString();

- Geeft de cursor terug als een tekenreeks met de vorm `Cursor(regel, kolom)`.

##### Het prototype Range

    Range();

- Constructor. Aanroepen van `new Range()` geeft een bereik op (0, 0) - (0, 0) terug.

    Range(Cursor begin, Cursor eind);

- Constructor. Aanroepen van `new Range(`begin`, `eind`)` geeft de Reeks (`begin`, `eind`) terug.

    Range(int beginRegel, int beginKolom, int eindRegel, int eindKolom);

- Constructor. Aanroepen van `new Range(`beginRegel`, `beginKolom`, `eindeRegel`, `eindKolom`)` geeft de Reeks van (`beginRegel`, `beginKolom`) tot (`eindeRegel`, `eindKolom`).

    Range(Range andere);

- Constructor kopiëren. Geeft een kopie terug van Range `andere`.

    Reeks Range.clone();

- Geeft een kloon van de reeks terug.

  Voorbeeld: `var clone = range.clone();`

    bool Range.isEmpty();

- Geeft `true` terug, als zowel begin als einde cursor gelijk zijn.

  Voorbeeld: `var empty = range.isEmpty();`

  Sinds: &kde; 4.11

    bool Range.isValid();

- Geeft `true` terug, als zowel begin als einde cursor geldig zijn, anders `false`.

  Voorbeeld: `var valid = range.isValid();`

    Range Range.invalid();

- Geeft de Reeks van (-1, -1) tot (-1, -1) terug.

    bool Range.contains(Cursor cursor);

- Geeft `true` terug, als de reeks de cursorpositie bevat, anders `false`.

    bool Range.contains(Range andere);

- Geeft `true` terug, als deze reeks de Reeks`andere` bevat, anders `false`.

    bool Range.containsColumn(int kolom);

- Geeft `true` terug, als `kolom` zich in het half open interval `[start.column, end.column)` bevindt, anders `false`.

    bool Range.containsLine(int regel);

- Geeft `true` terug, als `regel` zich in het half open interval `[start.line, end.line)` bevindt, anders `false`.

    bool Range.overlaps(Range overig);

- Geeft `true` terug, als deze reeks en de reeks`overig` een gebied delen, anders `false`.

    bool Range.overlapsLine(int regel);

- Geeft `true` terug, als `regel` zich in het interval `[start.line, end.line)` bevindt, anders `false`.

    bool Range.overlapsColumn(int kolom);

- Geeft `true` terug, als `kolom` zich in het interval `[start.column, end.column)` bevindt, anders `false`.

    bool Range.onSingleLine();

- Geeft `true` terug, als zowel begin als einde van de reeks op dezelfde regel, &ie; als `Range.start.line == Range.end.line`.

  Sinds: &kde; 4.9

    bool Range.equals(Range overig);

- Geeft `true` terug, als deze reeks de Reeks `andere` gelijk zijn, anders `false`.

    String Range.toString();

- Geeft de reeks terug als een tekenreeks van de vorm `Range(Cursor(line, column), Cursor(line, column))`.

#### Globale functies

Deze sectie geeft een lijst met alle globale functies.

##### Lezen & invoegen van bestanden

    String read(String bestand);

- Zal het gegeven `bestand` zoeken relatief ten opzichte van de map `katepart/script/files` en en de inhoud teruggeven als een tekenreeks.

    void require(String bestand);

- Zal het gegeven `bestand` zoeken relatief ten opzichte van de map `katepart/script/libraries` en het evalueren. `require` is intern beschermd tegen meervoudig invoegen van hetzelfde `bestand`.

  Sinds: &kde; 4.10

##### Debugging

    void debug(String tekst);

- Stuurt `tekst` naar `stdout` in de console na het starten van de toepassing.

##### Vertaling

Om volledige lokalisatie te ondersteunen zijn er verschillende functies om tekenreeksen in scripts te vertalen, namelijk `i18n`, `i18nc`, `i18np` en `i18ncp`. Deze functies gedragen zich op precies dezelfde manier zoals in Vertalingsfuncties van &kde;.

De vertalingfuncties vertalen de omwikkelde tekenreeksen via het vertalingssysteem van &kde; naar de in de toepassing gebruikte taal. Tekenreeksen in scripts die worden ontwikkeld in de officiële broncode van &kappname; worden automatisch geëxtraheerd en vertaalbaar gemaakt. Met andere woorden, als ontwikkelaar van &kappname; hoeft u zich niet bezig te houden met extraheren en vertalen. Opgemerkt moet echter worden dat de vertaling alleen werkt binnen de infrastructuur van $kde;. Dat wil zeggen dat nieuwe tekenreeksen in scripts van derden ontwikkeld buiten &kde; niet worden vertaald. Neem dus in overweging om uw scripts aan &kate; bij te dragen zodat vertaling mogelijk wordt.

    void i18n(String tekst, arg1, ...);

- Vertaalt `text` in de taal die wordt gebruikt door de toepassing. De argumenten `arg1`, ..., zijn optioneel en worden gebruikt om plaatshouders `%1`, `%2`, etc. te vervangen.

    void i18nc(String context, String tekst, arg1, ...);

- Vertaalt `text` in de taal die wordt gebruikt door de toepassing. Bovendien is de tekenreeks `context` zichtbaar voor de vertalers, zodat zij een betere vertaling kunnen produceren. De argumenten `arg1`, ..., zijn optioneel en worden gebruikt om plaatshouders `%1`, `%2`, etc. te vervangen.

    void i18np(String enkelvoud, String meervoud, int nummer, arg1, ...);

- Vertaalt ofwel `enkelvoud` of `meervoud` in de taal die wordt gebruikt door de toepassing, afhankelijk van het gegeven `nummer`. De argumenten `arg1`, ..., zijn optioneel en worden gebruikt om plaatshouders `%1`, `%2`, etc. te vervangen.

    void i18ncp(String context, String eenvoud, String meervoud, int nummer, arg1, ...);

- Vertaalt `enkelvoud` of`meervoud` in de taal die wordt gebruikt door de toepassing, afhankelijk van het gegeven nummer. Bovendien is de tekenreeks `context` zichtbaar voor de vertalers, zodat zij een betere vertaling kunnen produceren. De argumenten `arg1`, ..., zijn optioneel en worden gebruikt om plaatshouders `%1`, `%2`, etc. te vervangen.

#### De API voor weergave

Wanneer een script wordt uitgevoerd, dan is er een globale variabele `view` die de huidige actieve editor-view representeert. Het volgende is een lijst met alle beschikbare weergavefuncties.

    Cursor view.cursorPosition()

- Geeft de huidige cursorpositie in het beeld terug.

    void view.setCursorPosition(int line, int column);
    void view.setCursorPosition(Cursor cursor);

- Stelt de huidige cursorpositie in op ofwel (regel, kolom) of op de gegeven cursor.

    Cursor view.virtualCursorPosition();

- Geeft de virtuele cursorpositie terug waarin elke tab telt voor de overeenkomstige hoeveelheid spaties afhankelijk van de huidige tabbreedte.

    void view.setVirtualCursorPosition(int line, int column);
    void view.setVirtualCursorPosition(Cursor cursor);

- Stelt de huidige virtuele cursorpositie in op (regel, kolom) of op de gegeven cursor.

    String view.selectedText();

- Geeft de geselecteerde tekst terug. Als er geen tekst is geselecteerd dan is de tekenreeks leeg.

    bool view.hasSelection();

- Geeft `true` terug, als het beeld geselecteerde tekst heeft, anders `false`.

    Range view.selection();

- Geeft de geselecteerde tekstreeks terug. Als er geen tekst is geselecteerd dan is de tekenreeks ongeldig.

    void view.setSelection(Range reeks);

- Stelt de geselecteerde tekst in op de gegeven reeks.

    void view.removeSelectedText();

- Verwijder de geselecteerde tekst. Als het beeld geen geselecteerde tekst bevat, dan doet dit niets.

    void view.selectAll();

- Selecteert de gehele tekst in het document.

    void view.clearSelection();

- Wist de tekstselectie zonder de tekst te verwijderen.

#### De API van Document

Wanneer een script uitgevoerd wordt is er een globale variabele `document` die het huidige actieve document representeert. Het volgende is een lijst met alle beschikbare documentfuncties.

    String document.fileName();

- Geeft de bestandsnaam van het document terug of een lege tekenreeks voor niet opgeslagen tekstbuffers.

    String document.url();

- Geeft de volledige url van het document terug of een lege tekenreeks voor niet opgeslagen tekstbuffers.

    String document.mimeType();

- Geeft het mime-type van het document terug of het mime-type `application/octet-stream` als er geen toepasselijk mime-type gevonden kan worden.

    String document.encoding();

- Geeft de nu gebruikte codering terug om het bestand op te slaan.

    String document.highlightingMode();

- Geeft de gebruikte globale accentueringmodus terug voor het gehele document.

    String document.highlightingModeAt(Cursor pos);

- Geeft de gebruikte accentueringmodus terug op de gegeven positie in het document.

    Array document.embeddedHighlightingModes();

- Geeft een reeks van accentueringmodi terug ingebed in dit document.

    bool document.isModified();

- Geeft `true` terug, als het document niet opgeslagen wijzigingen heeft(gemodificeerd), anders `false`.

    String document.text();

- Geef de gehele inhoud van het document terug in een enkele tekenreeks. Nieuwe regels zijn gemarkeerd met het teken nieuw-regel `\n`.

    String document.text(int vanafRegel, int vanafKolom, int totRegel, int totKolom);
    String document.text(Cursor vanaf, Cursor tot);
    String document.text(Range bereik);

- Geeft de tekst terug in het gegeven bereik. Het is aanbevolen de cursor te gebruiken en een versie gebaseerd op bereik voor betere leesbaarheid van de broncode.

    String document.line(int regel);

- Geeft de gegeven tekstregel terug als tekenreeks. De tekenreeks is leeg als de gevraagde regel buiten het bereik ligt.

    String document.wordAt(int regel, int kolom);
    String document.wordAt(Cursor cursor);

- Geeft het woord terug op de gegeven cursorpositie.

    Range document.wordRangeAt(int regel, int kolom);
    Range document.wordRangeAt(Cursor cursor);

- Geeft de reeks van het woord op de gegeven cursorpositie terug. De teruggeven reeks is ongeldig (zie Range.isValid()), als de tekstpositie zich na het eind van een regel bevindt. Als er geen woord is op de gegeven cursorpositie, zal een lege reeks worden teruggegeven.

  Sinds: &kde; 4.9

    String document.charAt(int regel, int kolom);
    String document.charAt(Cursor cursor);

- Geeft het teken terug op de gegeven cursorpositie.

    String document.firstChar(int regel);

- Geeft het eerste teken in de gegeven `regel` terug die geen witruimte is. Het eerste teken is in kolom 0. Als de regel leeg of alleen witruimte bevat, dan is de teruggegeven tekenreeks leeg.

    String document.lastChar(int regel);

- Geeft het laatste teken in de gegeven `regel` terug die geen witruimte is. Als de regel leeg of alleen witruimte bevat, dan is de teruggegeven tekenreeks leeg.

    bool document.isSpace(int regel, int kolom);
    bool document.isSpace(Cursor cursor);

- Geeft `true` terug, als het teken op de gegeven cursorpositie gelijk is aan een witruimte, anders `false`.

    bool document.matchesAt(int regel, int kolom, String tekst);
    bool document.matchesAt(Cursor cursor, String tekst);

- Geeft `true` terug, als de gegeven `tekst` overeenkomt met de overeenkomstige cursorpositie, anders `false`.

    bool document.startsWith(int regel, String tekst, bool skipWhiteSpaces);

- Geeft `true` terug als de regel begint met `tekst`, anders `false`. Het argument `skipWhiteSpaces` bepaalt of voorloopwitruimte genegeerd worden.

    bool document.endsWith(int regel, String tekst, bool skipWhiteSpaces);

- Geeft `true` terug als de regel eindigt met `tekst`, anders `false`. Het argument `skipWhiteSpaces` bepaalt of witruimte achteraan genegeerd wordt.

    bool document.setText(String tekst);

- Stelt de gehele documenttekst in.

    bool document.clear();

- Verwijdert de gehele tekst uit het document.

    bool document.truncate(int regel, int kolom);
    bool document.truncate(Cursor cursor);

- Kap de gegeven regel op de gegeven kolom of cursorpositie af. Geeft `true` terug bij succes of `false` als de gegeven regel geen deel is van het documentbereik.

    bool document.insertText(int regel, int kolom, String tekst);
    bool document.insertText(Cursor cursor, String tekst);

- Voeg de `tekst` op de cursorpositie in. Geeft `true` terug bij succes of `false`, als het document alleen-lezen is.

    bool document.removeText(int vanafRegel, int vanafKolom, int totRegel, int totKolom);
    bool document.removeText(Cursor vanaf, Cursor tot);
    bool document.removeText(Range bereik);

- Verwijdert de tekst in het gegeven bereik. Geeft `true` terug bij succes of `false`, als het document alleen-lezen is.

    bool document.insertLine(int regel, String tekst);

- Voegt tekst in de gegeven regel in. Geeft `true` terug bij succes of `false`, als het document alleen-lezen is of de regel niet in het documentbereik ligt.

    bool document.removeLine(int regel);

- Verwijdert de gegeven tekstregel. Geeft `true` terug bij succes of `false`, als het document alleen-lezen is of de regel niet in het documentbereik ligt.

    bool document.wrapLine(int regel, int kolom);
    bool document.wrapLine(Cursor cursor);

- Breekt de regel op de gegeven cursorpositie op. Geeft `true` terug bij succes, anders `false`, ⪚ als regel < 0.

  Sinds: &kde; 4.9

    void document.joinLines(int beginRegel, int eindRegel);

- Voegt de regels vanaf `beginRegel` tot `eindRegel` samen. Twee elkaar opvolgende tekstregels worden altijd gescheiden door een enkele spatie.

    int document.lines();

- Geeft het aantal regels in het document terug.

    bool document.isLineModified(int regel);

- Geeft `true` terug, als `regel` nu niet opgeslagen gegevens bevat.

  Sinds: &kde; 5.0

    bool document.isLineSaved(int regel);

- Geeft `true` terug, als `regel` is gewijzigd, maar het document is opgeslagen. Dus bevat de regel nu geen niet opgeslagen gegevens.

  Sinds: &kde; 5.0

    bool document.isLineTouched(int regel);

- Geeft `true` terug, als `regel` nu niet opgeslagen gegevens bevat of eerder is gewijzigd.

  Sinds: &kde; 5.0

    void document.findTouchedLine(int beginRegel, bool oplaag);

- Zoek naar de volgende aangeraakte regel beginnend bij `regel`. Het zoeken wordt uitgevoerd ofwel omhoog of omlaag afhankelijk van de zoekrichting gespecificeerd in `omlaag`.

  Sinds: &kde; 5.0

    int document.length();

- Geeft het aantal tekens in het document terug.

    int document.lineLength(int regel);

- Geeft de lengte van de `regel` terug.

    void document.editBegin();

- Begint een bewerkingsgroep voor groepering van ongedaan maken/opnieuw doen. Controleer altijd of `editEnd()` is aangeroepen als u `editBegin()` aanroept. Aanroepen van `editBegin()` gebruikt intern een referentieteller, &ie; deze aanroep kan genest worden.

    void document.editEnd();

- Beëindigt een bewerkingsgroep. De laatst aanroep van `editEnd()` (&ie; diegene voor de eerste aanroep van `editBegin()`) beëindigt de bewerkingsstap.

    int document.firstColumn(int regel);

- Geeft de eerste niet-witruimte kolom in de gegeven `regel` terug. Als er alleen witruimte in de regel bevindt, dan is de terugkeerwaarde `-1`.

    int document.lastColumn(int regel);

- Geeft de laatste niet-witruimte kolom in de gegeven `regel` terug. Als er alleen witruimte in de regel bevindt, dan is de terugkeerwaarde `-1`.

    int document.prevNonSpaceColumn(int regel, int kolom);
    int document.prevNonSpaceColumn(Cursor cursor);

- Geeft de kolom terug met een niet-witruimte teken beginnend bij de gegeven cursorpositie en achterwaarts zoeken.

    int document.nextNonSpaceColumn(int regel, int kolom);
    int document.nextNonSpaceColumn(Cursor cursor);

- Geeft de kolom terug met een niet-witruimte teken beginnend bij de gegeven cursorpositie en voorwaarts zoeken.

    int document.prevNonEmptyLine(int regel);

- Geeft de volgende niet-lege regel terug met een niet-witruimte tekens en achterwaarts zoeken.

    int document.nextNonEmptyLine(int regel);

- Geeft de volgende niet-lege regel terug met een niet-witruimte teken en voorwaarts zoeken.

    bool document.isInWord(String teken, int attribuut);

- Geeft `true` terug, als het gegeven `teken` met het gegeven `attribuut` deel van een woord kan zijn, anders `false`.

    bool document.canBreakAt(String teken, int attribuut);

- Geeft `true` terug, als het gegeven `teken` met het gegeven `attribuut` geschikt is om een regel af te breken, anders `false`.

    bool document.canComment(int beginAttribuut, int eindAttribuut);

- Geeft `true` terug, als een bereik beginnend en eindigend met de gegeven attributen geschikt is om als commentaar te worden aangemerkt, anders `false`.

    String document.commentMarker(int attribuut);

- Geeft de markeerder voor commentaar terug voor commentaar op een enkele regel voor een gegeven `attribuut`.

    String document.commentStart(int attribuut);

- Geeft de markeerder voor commentaar terug voor begin van commentaar over meerdere regels voor een gegeven `attribuut`.

    String document.commentEnd(int attribuut);

- Geeft de markeerder voor commentaar terug voor het einde van commentaar over meerdere regels voor een gegeven `attribuut`.

    Range document.documentRange();

- Geeft een reeks terug die het gehele document omvat.

    Cursor documentEnd();

- Geeft een cursor terug gepositioneerd in de laatste kolom van de laatste regel in het document.

    bool isValidTextPosition(int regel, int kolom);
    bool isValidTextPosition(Cursor cursor);

- Geeft `true` terug, als de gegeven cursorpositie is gepositioneerd op een geldige tekstpositie. Een tekstpositie is alleen geldig als het is gelokaliseerd aan het begin, in het midden, of aan het eind van een geldige regel. Verder is een tekstpositie ongeldig als het is gelokaliseerd in een Unicode-surrogaat.

  Sinds: &kde; 5.0

    int document.attribute(int regel, int kolom);
    int document.attribute(Cursor cursor);

- Geeft het attribuut terug op de gegeven cursorpositie.

    bool document.isAttribute(int regel, int kolom, int attribuut);
    bool document.isAttribute(Cursor cursor, int attribuut);

- Geeft `true` terug, als het attribuut op de gegeven cursorpositie gelijk is aan `attribuut`, anders `false`.

    String document.attributeName(int regel, int kolom);
    String document.attributeName(Cursor cursor);

- Geeft de attribuutnaam terug als leesbare tekst. Dit is gelijk aan de `itemData`-naam in de syntaxis-accentuering-bestanden.

    bool document.isAttributeName(int regel, int kolom, String naam);
    bool document.isAttributeName(Cursor cursor, String naam);

- Geeft `true` terug, als de attribuutnaam op een bepaalde cursorpositie overeenkomt met de gegeven `naam`, anders `false`.

    String document.variable(String sleutel);

- Geeft de waarde terug van de gevraagde documentvariabele `sleutel`. Als de documentvariabele niet bestaat, wordt een lege tekenreeks teruggegeven.

    void document.setVariable(String sleutel, String waarde);

- Stelt de waarde in van de gevraagde documentvariabele `sleutel`.

  Zie ook: Documentvariabelen van Kate

  Sinds: &kde; 4.8

    int document.firstVirtualColumn(int regel);

- Geeft de virtuele kolom terug van het eerste niet-witruimte-teken in de gegeven regel of `-1`, als de regel leeg is of alleen witruimte-tekens bevat.

    int document.lastVirtualColumn(int regel);

- Geeft de virtuele kolom terug van het laatste niet-witruimte-teken in de gegeven regel of `-1`, als de regel leeg is of alleen witruimte-tekens bevat.

    int document.toVirtualColumn(int regel, int kolom);
    int document.toVirtualColumn(Cursor cursor);
    Cursor document.toVirtualCursor(Cursor cursor);

- Converteert de gegeven echte cursorpositie naar een virtuele cursorpositie, geeft ofwel een int terug of een cursor-object.

    int document.fromVirtualColumn(int regel, int virtueleKolom);
    int document.fromVirtualColumn(Cursor virtueleCursor);
    Cursor document.fromVirtualCursor(Cursor virtueleCursor);

- Converteert de gegeven virtuele cursorpositie naar een echte cursorpositie, geeft ofwel een int terug of een cursor-object.

    Cursor document.anchor(int regel, int kolom, Char teken);
    Cursor document.anchor(Cursor cursor, Char teken);

- Zoekt achterwaarts naar het gegeven teken te beginnen vanaf de gegeven cursor. Als voorbeeld, als '(' als teken wordt meegegeven, dan geeft deze functie de positie terug van de openingings '('. Dit houdt rekening met aantallen, &ie; andere '(...)' worden genegeerd.

    Cursor document.rfind(int regel, int kolom, String tekst, int attribuut = -1);
    Cursor document.rfind(Cursor cursor, String tekst, int attribuut = -1);

- Zoek de gegeven tekst achterwaarts met het juiste `attribuut`. Het argument `attribuut` wordt genegeerd als het is ingesteld op `-1`. De teruggegeven cursor is ongeldig, als de tekst niet is gevonden.

    int document.defStyleNum(int regel, int kolom);
    int document.defStyleNum(Cursor cursor);

- Geeft de standaard stijl terug op de gegeven cursorpositie.

    bool document.isCode(int regel, int kolom);
    bool document.isCode(Cursor cursor);

- Geeft `true` terug, als het attribuut op de gegeven cursorpositie niet gelijk is aan alle volgende stijlen: `dsComment`, `dsString`, `dsRegionMarker`, `dsChar`, `dsOthers`.

    bool document.isComment(int regel, int kolom);
    bool document.isComment(Cursor cursor);

- Geeft `true` terug, als het attribuut van het teken op de cursorpositie gelijk is aan `dsComment`, anders `false`.

    bool document.isString(int regel, int kolom);
    bool document.isString(Cursor cursor);

- Geeft `true` terug, als het attribuut van het teken op de cursorpositie gelijk is aan `dsString`, anders `false`.

    bool document.isRegionMarker(int regel, int kolom);
    bool document.isRegionMarker(Cursor cursor);

- Geeft `true` terug, als het attribuut van het teken op de cursorpositie gelijk is aan `dsRegionMarker`,anders `false`.

    bool document.isChar(int regel, int kolom);
    bool document.isChar(Cursor cursor);

- Geeft `true` terug, als het attribuut van het teken op de cursorpositie gelijk is aan `dsChar`, anders `false`.

    bool document.isOthers(int regel, int kolom);
    bool document.isOthers(Cursor cursor);

- Geeft `true` terug, als het attribuut van het teken op de cursorpositie gelijk is aan `dsOthers`, anders `false`.

## Extensies van de tekstinvoercomponent

Uitbreidingen van de bewerkercomponent breiden KatePart, de geavanceerde tekstbewerkercomponent die in vele &kde;-toepassingen, zoals &kate;, &kwrite;, Kile en KDevelop worden gebruikt. Een plug-in voor de bewerkercomponent stelt u in staat om de functionaliteit van de bewerker in elk en alle van deze programma's uit te breiden.

Om te beginnen, zie de Inleiding in de KTextEditor Plug-in in &kde; TechBase. Voor nog meer, zie de Geavanceerde inleiding, ook in TechBase.

U kunt de complete API-documentatie vinden in de &kde; API-referentie.