Utöka

Inledning
Som alla avancerade editorer erbjuder en mängd sätt att utöka dess funktionalitet. Du kan skriva enkla skript för att lägga till funktionalitet med Javascript. Till sist, när du väl har utökat , är du välkommen att gå med och dela med dig av dina förbättringar med hela världen.

Arbeta med syntaxfärgläggning

Översikt
Syntaxfärgläggning är det som gör att editorn automatiskt visar text med olika stilar/färger, beroende på strängens funktion i relation till filens syfte. Till exempel i programkällkod, så kan kontrollsatser visas i fetstil, medan datatyper och kommentarer får annorlunda färg än resten av texten. Det här ökar textens läsbarhet väsentligt, och hjälper på så sätt författaren att vara effektivare och mer produktiv.
En funktion i Perl, som visas med syntaxfärgläggning.
En funktion i Perl, som visas med syntaxfärgläggning.
Samma funktion i Perl utan syntaxfärgläggning.
Samma funktion i Perl utan syntaxfärgläggning.
Av de två exemplen, vilket är lättast att läsa?
levereras med ett flexibelt, anpassningsbart och avancerat system för att göra syntaxfärgläggning, och standarddistributionen tillhandahåller definitioner för ett brett område av programspråk, formaterings- och skriptspråk samt andra textfilformat. Dessutom kan du tillhandahålla dina egna definitioner med enkla -filer.
detekterar automatiskt de riktiga syntaxreglerna när du öppnar en fil, baserat på filens -typ, som avgörs av dess filändelse, eller om den inte har någon, dess innehåll. Skulle du råka ut för ett dåligt val, kan du ställa in syntaxen som används för hand med menyn Verktyg Färgläggning.
Stilarna och färgerna som används av varje syntaxfärgläggningsläge kan anpassas under fliken Färgläggnińgstextstilar i inställningsdialogrutan, medan -typerna och filändelserna det ska användas för hanteras under fliken Lägen och filtyper.
Syntaxfärgläggning finns för att förbättra läsbarheten för riktig text, men du kan inte lita på att den validerar din text. Att markera text för syntax kan vara svårt, beroende på formatet som du använder, och i vissa fall är upphovsmännen till syntaxreglerna stolta om 98 procent av texten visas korrekt, även om du behöver en ovanlig stil för att se de felaktiga 2 procenten.
Du kan ladda ner uppdaterade eller nya definitioner av syntaxfärgläggning från s webbplats genom att klicka på knappen Ladda ner färgläggningsfiler... på fliken Lägen och filtyper i inställningsdialogrutan.

s syntaxfärgläggningssystem
Det här avsnittet beskriver s syntaxfärgläggningsmekanism i mer detalj. Det är avsett för dig, om du vill veta mer om den, eller om du vill skapa och ändra syntaxdefinitioner.

Hur det fungerar
Så fort du öppnar en fil, är en av de första sakerna som -editorn gör att avgöra vilken syntaxdefinition som ska användas för filen. När filens text läses in, och medan du skriver i den, så analyserar syntaxfärgläggningssystemet texten enligt reglerna som definieras i syntaxdefinitionen och markerar var i den som olika sammanhang och stilar börjar och slutar.
När du skriver in text i dokumentet, så analyseras och markeras den nya texten i farten, så att om du tar bort ett tecken som markeras som början eller slutet på ett sammanhang, så ändras stilen på den omgivande texten i enlighet med detta.
Syntaxdefinitioner som används av s syntaxfärgläggningssystem är -filer, som innehåller
Regler för att detektera funktionen hos text, organiserade i sammanhangsblock
Listor med nyckelord
Definitioner av stilobjekt
När texten analyseras utvärderas detekteringsreglerna i den ordning som de definierades, och om början på den nuvarande strängen matchar en regel, så används motsvarande sammanhang. Startpunkten i texten flyttas till den sista punkten där regeln matchade, och en ny genomgång av reglerna sker, med början i sammanhanget som anges av den matchande regeln.

Regler
Detekteringsreglerna är centrala för färgläggningsdetekteringssystemet. En regel är en sträng, ett tecken eller ett reguljärt uttryck som texten som ska analyseras matchas mot. Den innehåller information om vilken stil som ska användas för den delen av texten som matchar. Den kan byta arbetssammanhanget för systemet, antingen till ett sammanhang som anges explicit, eller till det föregående sammanhanget som användes av texten.
Reglerna organiseras i sammanhangsgrupper. En sammanhangsgrupp används för de huvudsakliga koncepten i formatets text, till exempel textsträngar inom citationstecken eller kommentarblock i programkällkod. Det här försäkrar att färgläggningssystemet inte behöver gå igenom alla regler när det inte är nödvändigt, och att vissa teckensekvenser i texten kan hanteras annorlunda beroende på det nuvarande sammanhanget.
Sammanhang kan skapas dynamiskt för att till exempel tillåta användning av instansspecifik data i regler.

Sammanhangsstilar och nyckelord
I vissa programspråk, hanteras heltal annorlunda än flyttal av kompilatorn (programmet som översätter källkoden till körbart binärformat), och det kan finnas tecken som har en särskild mening i en sträng med citationstecken. I sådana fall är det vettigt att visa dem på ett annat sätt än omgivningen så att de är lätta att identifiera när texten läses. Så även om de inte representerar speciella sammanhang, så kan de betraktas som sådana av syntaxfärgläggningssystemet, så att de kan markeras för att visas på ett annorlunda sätt.
En syntaxdefinition kan innehålla så många stilar som krävs för att täcka koncepten i det format den används för.
I många format finns det en lista på ord som representerar ett speciellt koncept. Till exempel i programspråk, så är kontrollsatser ett koncept, namn på datatyper ett annat, och inbyggda funktioner i språket ett tredje. s syntaxfärgläggningssystem kan använda sådana listor för att detektera och markera ord i texten för att visa koncepten för textformaten.

Standardstilar
Om du öppnar en C++ källkodsfil, en källkodsfil och ett HTML-dokument i , så ser du att även om formaten är olika, och olika ord därför väljes för särskild behandling, så är färgerna som används samma. Det här beror på att har en fördefinierad lista med standardstilar, som används av varje individuell syntaxdefinition.
Det här gör det lätt att känna igen liknande koncept i olika textformat. Kommentarer finns till exempel i nästa alla program-, skript- eller formateringsspråk, och när de visas med samma stil i alla språk, behöver du inte stanna och tänka efter för att identifiera dem i texten.
Alla stilar i en syntaxdefinition använder en av standardstilarna. Några få syntaxdefinitioner använder fler stilar än det finns som standard, så om du ofta använder ett format, kan det vara värt att titta i inställningsdialogrutan för att se om några koncept använder samma stil. Det finns till exempel bara en standardstil för strängar, men eftersom programspråket Perl hanterar två sorters strängar, kan du utöka färgläggningen genom att ställa in dessa så att de skiljer sig något. Alla tillgängliga standardstilar förklaras senare.

formatet för syntaxfärgläggningsdefinitioner

Översikt
använder ramverket för syntaxfärgläggning från KDE Ramverk. XML-standardfilen för färgläggning som levereras med kompileras normalt i syntaxfärgläggningsbiblioteket.
Det här avsnittet är en översikt av färgläggningsdefinitionernas -format. Det beskriver huvudkomponenterna och deras betydelse och användning, och går djupare in i detaljerna för detekteringsreglerna.
Den formella definitionen, som också kallas XSD finns i arkivet för syntaxfärgläggning i filen language.xsd.
Egna .xml-färgläggningsdefinitionsfiler finns i org.kde.syntax-highlighting/syntax/ i användarkatalogen som hittas med qtpaths --paths GenericDataLocation, och som oftast är $HOME/.local/share.
På är filerna placerade i %USERPROFILE%/AppData/Local/org.kde.syntax-highlighting/syntax. %USERPROFILE% expanderas oftast till C:\\Users\\användare.

Huvudkomponenter i s färgläggningsdefinitioner
En syntaxfärgläggningsfil innehåller ett huvud som anger XML-versionen: 	

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

Definitionsfilens rot är elementet language. Följande egenskaper är tillgängliga: 	 Egenskaper som krävs:
name anger språkets namn. Det visas senare i menyer och dialogrutor.
section anger kategorin.
extensions definierar filändelser, såsom "*.cpp;*.h".
version anger aktuell version av definitionsfilen i form av ett heltal. När en definitionsfil för färgläggning ändras, försäkra dig om att talet ökas.
kateversion anger senaste version av som stöds.
Valfria egenskaper:
mimetype associerar filers -typ.
casesensitive definierar om nyckelord är skiftlägeskänsliga eller inte.
priority krävs om en annan syntaxfärgläggningsfil använder samma filändelse. Den högsta prioriteten vinner.
author innehåller författarens namn och e-postadress.
license innehåller licensen, oftast MIT-licensen för nya syntaxfärgläggningsfiler.
stil innehåller språket som tillhandahålls och används av indenterare för egenskapen required-syntax-style.
hidden definierar om namnet ska visas i s menyer.
Nästa rad kan alltså se ut så här:

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

Därefter kommer elementet highlighting som innehåller det valfria elementet list och det nödvändiga elementen contexts och itemDatas. 	 list element innehåller en lista med nyckelord. I det här fallet är nyckelorden class och const. Du kan lägga till så många listor som du behöver.
Elementet contexts innehåller alla sammanhang. Det första sammanhanget är förvalt som start för färgläggningen. Det finns två regler i sammanhanget Normal Text som matchar listan av nyckelord med namnet något-namn och en regel som detekterar ett citationstecken och byter sammanhang till string. För att lära dig mer om regler, läs nästa kapitel.
Den tredje delen är elementet itemDatas. Det innehåller alla färger och teckenstilar som behövs av sammanhangen och reglerna. I det här exemplet används itemData Normal Text, String och Keyword.

<highlighting>
    <list name="något-namn">
      <item> class </item>
      <item> const </item>
    </list>
    <contexts>
      <context attribute="Normal Text" lineEndContext="#pop" name="Normal Text" >
        <keyword attribute="Keyword" context="#stay" String="något-namn" />
        <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>

Den sista delen av färgläggningsdefinitionen är den valfria sektionen general. Den kan innehålla information om nyckelord, kodvikning, kommentarer och indentering. 	 Sektionen comment definierar den sträng som enradskommentarer inleds med. Du kan också definiera en flerradskommentar med multiLine och den ytterligare egenskapen end. Det är användbart när användaren trycker på snabbtangenten som motsvarar kommentera/avkommentera.
Sektionen keywords definierar om listor med nyckelord är skiftlägeskänsliga eller inte. Andra egenskaper förklaras senare.

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

Sektionerna i detalj
Den här delen beskriver alla tillgängliga egenskaper för sammanhang, itemData, nyckelord, kommentarer, kodvikning och indentering.
Elementet context hör till gruppen contexts. Själva sammanhanget definierar sammanhangsspecifika regler, som vad som ska ske om färgläggningssystemet når slutet på en rad. Tillgängliga egenskaper är: 	 name anger sammanhangets namn. Regler använder namnet för att ange sammanhanget att byta till om regeln matchar.
lineEndContext definierar sammanhanget som färgläggningssystemet byter till om det når ett radslut. Det kan antingen vara namnet på ett annat sammanhang, #stay för att inte byta sammanhang (dvs. göra ingenting) eller #pop som gör att det lämnar sammanhanget. Det är till exempel möjligt att använda #pop#pop#pop för att återgå tre steg, eller till och med #pop#pop!Annat_Sammanhang för att återgå två steg och byta till sammanhanget som heter Annat_Sammanhang.
lineEmptyContex definierar sammanhanget om en tom rad påträffas. Förval: #stay.
fallthroughdefinierar om färgläggningssystemet byter till sammanhanget som anges i fallthroughContext om ingen regel matchar. Förval: false.
fallthroughContext anger nästa sammanhang om ingen regel matchar.
dynamic om true kommer sammanhanget ihåg strängar/platsmarkörer som sparats av dynamiska regler. Det behövs till exempel för HERE-dokument. Förval: false.
Elementet itemData är i gruppen itemDatas. Det definierar teckenstilen och färgerna. Det är alltså möjligt att definiera egna stilar och färger. Dock rekommenderar vi att du håller dig till standardstilarna om möjligt, så att användaren alltid ser samma färger använda i olika språk. Ibland finns det dock inget annat sätt, och det är nödvändigt att ändra färg- och teckenegenskaper. Egenskapens namn och defStyleNum krävs, övriga är valfria. Tillgängliga egenskaper är: 	 name anger namnet på itemData. Sammanhang och regler använder namnet i egenskapen attribute för att referera till itemData.
defStyleNum definierar vilken standardstil som ska användas. Tillgängliga standardstilar förklaras i detalj senare.
color definierar en färg. Giltiga format är '#rrggbb' eller '#rgb'.
selColor definierar markeringens färg.
italic om true, är texten kursiv.
bold om true, är texten i fetstil.
underline om true, är texten understruken.
strikeout om true, är texten överstruken.
spellChecking om true, stavningskontrolleras texten.
Elementet keywords i gruppen general definierar nyckelordens egenskaper. Tillgängliga egenskaper är: 	 casesensitive kan vara true eller false. Om det är true, matchas alla nyckelord skiftlägeskänsligt.
weakDeliminator är en lista med tecken som inte fungerar som ordavgränsare. Punkt '.' är till exempel en ordavgränsare. Med antagandet att ett nyckelord i en list innehåller en punkt, matchar det bara om du anger att punkten är en svag avgränsare.
additionalDeliminator definierar ytterligare avgränsare.
wordWrapDeliminator definierar tecken som en radbrytning kan ske efter.
Standardavgränsare och radbrytningsavgränsare är tecknen .():!+,-<=>%&*/;?[]^{|}~\, mellanslag (' ') och tabulator ('\t').
Elementet comment i gruppen comments definierar kommentaregenskaper som används för Verktyg Kommentera och Verktyg Avkommentera. Tillgängliga egenskaper är: 	 name är antingen singleLine eller multiLine. Om du väljer multiLine krävs egenskaperna end och region.
start definierar strängen som används för att inleda en kommentar. I C++ skulle det vara "/*".
end definierar strängen som används för att avslutar en kommentar. I C++ skulle det vara "*/".
region ska vara namnet på den vikbara flerraderskommentaren. Med antagandet att du har beginRegion="Comment" ... endRegion="Comment" i dina regler, ska du använda region="Comment". På så sätt fungerar avkommentering även om du inte markerar all text i en flerraderskommentar. Markören måste bara vara inne i flerraderskommentaren.
Elementet folding i gruppen general definierar kodvikningsegenskaper. Tillgängliga egenskaper är: 	 indentationsensitive om true läggs kodvikningsmarkörerna till baserat på indentering, som i skriptspråket Python. Oftast behöver du inte ange det, eftersom det har det förvalda värdet false.
Elementet indentation i gruppen general definierar vilken identerare som ska användas. Dock rekommenderar vi starkt att du utelämnar elementet, eftersom intenteraren oftast anges genom att definiera en filtyp eller genom att lägga till lägesrader i textfilen. Om du dock anger en indenterare, tvingar du användaren att använda en viss indentering, vilket kanske inte alls uppskattas. Tillgängliga egenskaper är: 	 mode är namnet på indenteraren. Indenterare som för närvarande är tillgängliga är:normal, cstyle, haskell, lilypond, lisp, python, ruby och xml.

Tillgängliga standardstilar
Standardstilar har redan förklarats. En kort sammanfattning: Standardstilar är fördefinierade stilar för teckensnitt och färger.
Allmänna standardstilar: 	 dsNormal, när ingen särskild färgläggning krävs.
dsKeyword, nyckelord för inbyggda språk.
dsFunction, funktionsanrop och definitioner.
dsVariable, om tillämpligt: variabelnamn (t.ex. $enVariabel i PHP eller Perl).
dsControlFlow, nyckelord för kontrollflöde såsom if, else, switch, break, return, yield, ...
dsOperator, operatorer såsom + - * / :: < >
dsBuiltin, inbyggda funktioner, klasser och objekt.
dsExtension, vanliga ändelser såsom Qt-klasser och funktioner eller makron i C++ och Python.
dsPreprocessor, preprocessorsatser eller makrodefinitioner.
dsAttribute, anmärkningar som @override och __declspec(...).
Strängrelaterade standardstilar: 	 dsChar, enstaka tecken såsom 'x'.
dsSpecialChar, tecken med speciell betydelse i strängar som undantag, ersättningar eller operatorer i reguljära uttryck.
dsString, strängar såsom "hej allihop".
dsVerbatimString, ordagranna eller obehandlade strängar som 'raw \backlash' i Perl, CoffeeScript och skal, samt r'\raw' i Python.
dsSpecialString, SQL-satser, reguljära uttryck, HERE-dokument, Latex-matematikläge, ...
dsImport, import, inkludering och require för moduler.
Nummerrelaterade standardstilar: 	 dsDataType, inbyggda datatyper såsom int, void, u64.
dsDecVal, decimala värden.
dsBaseN, värden med en bas skild från 10.
dsFloat, flyttalsvärden.
dsConstant, inbyggda och användardefinierade konstanter såsom PI.
Kommentar- och dokumentationsrelaterade standardstilar: 	 dsComment, kommentarer.
dsDocumentation, /** dokumentationskommentarer */ eller """dokumentsträngar""".
dsAnnotation, dokumentationskommandon som @param, @brief.
dsCommentVar, variabelnamnen som används i ovanstående kommandon, som "exempel" i @param exempel.
dsRegionMarker, områdesmarkeringar som //BEGIN, //END i kommentarer.
Andra standardstilar: 	 dsInformation, anmärkningar och tips som @note i doxygen.
dsWarning, varningar som @warning i doxygen.
dsAlert, specialord som TODO, FIXME, XXXX.
dsError, färgläggning av fel och felaktig syntax.
dsOthers, när ingenting annat passar in.

Regler för syntaxdetektering
Den här sektionen beskriver reglerna för syntaxdetektering.
Varje regel kan matcha noll eller flera tecken i början av strängen som de ska testas med. Om regeln matchar, så tilldelas de matchande tecknen stilen eller egenskapen som definieras av regeln. En regel kan också begära att det nuvarande sammanhanget byts.
En regel ser ut så här:

<Regelnamn attribute="(identifierare)" context="(identifierare)" [regelspecifika egenskaper] />

Ordet attribute identifierar stilen som ska användas för tecken som matchar med namn eller index, och context identifierar sammanhanget som ska användas i fortsättningen.
Sammanhanget kan identifieras av:
En identifierare, som är namnet på det andra sammanhanget.
En ordning som talar om att färgläggningen ska stanna kvar i det nuvarande sammanhanget (#stay), eller gå tillbaka till det föregående sammanhanget som använts i strängen (#pop).
För att gå tillbaka flera steg, kan nyckelordet #pop upprepas: #pop#pop#pop
En ordning följd av ett utropstecken (!) och en identifierare, som gör att färgläggningen först följer ordningen och därefter byter till det andra sammanhanget, t.ex. #pop#pop!Annat_sammanhang.
Vissa regler kan ha delregler, bara utvärderas om huvudregeln matchar. Hela den matchande strängen kommer att få egenskapen som definieras av huvudregeln. En regel med en delregel ser ut så här:

<Regelnamn (egenskaper)>
  <Delregelnamn (egenskaper) />
  ...
</Regelnamn>

Regelspecifika egenskaper varierar och beskrivs i följande avsnitt.

Gemensamma egenskaper
Alla regler har följande egenskaper gemensamma och är tillgängliga på alla ställen (gemensamma egenskaper) visas. Egenskaperna attribute och context är nödvändiga, alla övriga är valfria.
attribute: En egenskap avbildas på en definierad itemData.
context: Anger sammanhanget som färgläggningssystemet byter till om regeln matchar.
beginRegion: Inled ett kodvikningsblock. Förval: unset.
endRegion: Avsluta ett kodvikningsblock. Förval: unset.
lookAhead: Om true behandlar inte färgläggningssystemet matchningens längd. Förval: false.
firstNonSpace: Matcha bara om strängen är den första förutom blanktecken på raden. Förval: false.
column: Matcha bara om kolumnen matchar. Förval: unset.

Dynamiska regler
Vissa regler tillåter den valfria egenskapen dynamic med Boolesk typ, som har förvalt värde false. Om dynamic är true, kan en regel använda platsmarkörer som representerar texten som matchas av en regel med ett reguljärt uttryck som byter till nuvarande sammanhang med sin egenskap string eller char. I en string ersätts platsmarkören %N (där N är ett tal) med motsvarande N i det anropande reguljära uttrycket. I en char måste platsmarkören vara ett tal N och det ersätts med första tecknet i motsvarande N i det anropande reguljära uttrycket. Närhelst en regel tillåter den här egenskapen, innehåller den (dynamic).
dynamic: kan vara (true | false).

Reglerna i detalj
DetectChar 	 Detektera ett enda specifikt tecken. Används ofta för att till exempel hitta slutet på strängar inom citationstecken.

<DetectChar char="(tecken)" (gemensamma egenskaper) (dynamisk) />

Egenskapen char definierar tecknet som ska matchas.
Detect2Chars 	 Detektera två angivna tecken i en definierad ordning.

<Detect2Chars char="(tecken)" char1="(tecken)" (gemensamma egenskaper) (dynamisk) />

Egenskapen char definierar det första tecknet som ska matcha, char1 det andra.
AnyChar 	 Detektera ett tecken i en angiven teckenmängd.

<AnyChar String="(sträng)" (gemensamma egenskaper) />

Egenskapen String definierar teckenmängden.
StringDetect 	 Detektera en sträng exakt.

<StringDetect String="(sträng)" [insensitive="TRUE|FALSE;"] (gemensamma egenskaper) (dynamisk) />

Egenskapen String definierar strängen som ska matcha. Egenskapen insensitive (okänslig) är normalt FALSE (FALSK) och skickas med till strängjämförelsefunktionen. Om värdet är TRUE (SANT) så används en jämförelse som inte bryr sig om skiftläge.
WordDetect 	 Detektera en exakt sträng, men kräv dessutom ordgränser som en punkt '.' eller ett blanktecken i början och slutet av ordet. Betrakta \b<string>\b som ett reguljärt uttryck, men snabbare än regeln RegExpr.

<WordDetect String="(sträng)" [insensitive="TRUE|FALSE;"] (gemensamma egenskaper) (dynamisk) />

Egenskapen String definierar strängen som ska matcha. Egenskapen insensitive (okänslig) är normalt FALSE (FALSK) och skickas med till strängjämförelsefunktionen. Om värdet är TRUE (SANT) så används en jämförelse som inte bryr sig om skiftläge.
Sedan: ( 4.5)
RegExpr 	 Matchar med ett reguljärt uttryck.

<RegExpr String="(sträng)" [insensitive="TRUE|FALSE;"] [minimal="TRUE| FALSE"] (gemensamma egenskaper) (dynamisk) />

Egenskapen String definierar det reguljära uttrycket.
Egenskapen insensitive (okänslig) är normalt FALSE (FALSK) och skickas med det reguljära uttrycket.
Egenskapen minimal är normalt FALSE (FALSK) och skickas med det reguljära uttrycket.
Eftersom reglerna alltid matchas mot början av den nuvarande strängen, så anger ett reguljärt uttryck som börjar med en hatt (^) att regeln bara ska matchas mot radens början.
Se Reguljära uttryck för mer information om dem.
keyword 	 Detektera ett nyckelord från en angiven lista.

<keyword String="(listnamn)" (gemensamma egenskaper) />

Egenskapen String identifierar en lista på nyckelord med namn. En lista med det namnet måste finnas.
Färgläggningssystemet behandlar nyckelordsregler på ett mycket optimerat sätt. Det gör det absolut nödvändigt att alla nyckelord som ska matchas måste omges med definierade avgränsare, antingen underförstått (standardavgränsare) eller explicit definierade inne i egenskapen additionalDeliminator i taggen keywords.
Om ett nyckelord som ska matchas måste innehålla ett skiljetecken, måste detta tecken läggas till i egenskapen weakDeliminatori taggen keywords. Detta tecken förlorar då sin avgränsningsegenskap i alla regler med keyword.
Int 	 Detektera ett heltal.

<Int (gemensamma egenskaper) (dynamisk) />

Den här regeln har inga specifika egenskaper. Delregler används typiskt för att detektera kombinationer av L och U efter talet, som anger heltalstypen i programkod. I själva verket tillåts alla regler som delregler, även om DTD:n bara tillåter delregeln StringDetect.
Följande exempel matchar heltal som följs av tecknet 'L'.

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

Float 	 Detektera ett flyttal.

<Float (gemensamma egenskaper) />

Den här regeln har inga specifika egenskaper. AnyChar tillåts som en delregel, och används typiskt för att detektera kombinationer, se regeln Int för en referens.
HlCOct 	 Detektera en oktal talrepresentation.

<HlCOct (gemensamma egenskaper) />

Den här regeln har inga specifika egenskaper.
HlCHex 	 Detektera en hexadecimal talrepresentation.

<HlCHex (gemensamma egenskaper) />

Den här regeln har inga specifika egenskaper.
HlCStringChar 	 Detektera ett undantaget tecken.

<HlCStringChar (gemensamma egenskaper) />

Den här regeln har inga specifika egenskaper.
Det matchar bokstavsrepresentationer av osynliga tecken som ofta används i programkod, till exempel \n (nyrad) eller \t (tabulator).
Följande tecken matchar om de följer ett bakstreck (\): abefnrtv"'?. Dessutom matchar undantagna hexadecimala tal, som till exempel \xff och undantagna oktala tal, till exempel \033.
HlCChar 	 Detektera ett C-tecken.

<HlCChar (gemensamma egenskaper) />

Den här regeln har inga specifika egenskaper.
Det matchar C-tecken omgivna av apostrofer (till exempel 'c'). Apostroferna kan innehålla ett enkelt tecken eller en teckenföljd. Se HlCStringChar för matchade teckenföljder.
RangeDetect 	 Detektera en sträng med definierade start- och sluttecken.

<RangeDetect char="(tecken)"  char1="(tecken)" (gemensamma egenskaper) />

char definierar tecknet som inleder intervallet, och char1 tecknet som avslutar intervallet.
Användbar för att till exempel detektera små strängar inom citationstecken och liknande, men observera att eftersom färgläggningen arbetar med en rad i taget, så hittar det inte strängar som fortsätter på nästa rad.
LineContinue 	 Matchar ett angivet tecken vid radens slut.

<LineContinue (gemensamma egenskaper) [char="\"] />

Egenskapen char definierar valfritt tecken som ska matchas, förval är bakstreck ('\'). Ny sedan KDE 4.13.
Regeln är användbar för att byta sammanhang vid radslut. Det behövs till exempel i C/C++ för att fortsätta makron eller strängar.
IncludeRules 	 Inkludera regler från ett annat sammanhang eller språk/fil.

<IncludeRules context="sammanhangslänk" [includeAttrib="true|false"] />

Egenskapen context definierar vilket sammanhang som ska inkluderas.
Om den är en enkelt sträng innehåller den alla definierade regler i det nuvarande sammanhanget, till exempel:

<IncludeRules context="annat-sammanhang" />

Om strängen innehåller ## letar färgläggningssystemet efter ett sammanhang från en annan språkdefinition med angivet namn, exempelvis skulle

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

inkludera sammanhanget String från färgläggningsdefinitionen av C++.
Om egenskapen includeAttrib är true, ändras målegenskapen till källans egenskap. Det krävs till exempel för att kommentarer ska fungera om text som matchas av det inkluderade sammanhanget har en annan färgläggning än värdsammanhanget.
DetectSpaces 	 Detektera blanktecken.

<DetectSpaces (gemensamma egenskaper) />

Den här regeln har inga specifika egenskaper.
Använd den här regeln om du vet att det kan finnas flera blanktecken framför, till exempel i början av indenterade rader. Regeln hoppar över alla blanktecken på en gång, istället för att prova flera regler och hoppa över en åt gången eftersom den inte matchar.
DetectIdentifier 	 Detektera strängar för identifierare (som ett reguljärt uttryck: [a-zA-Z_][a-zA-Z0-9_]*).

<DetectIdentifier (gemensamma egenskaper) />

Den här regeln har inga specifika egenskaper.
Använd den här regeln för att hoppa över en sträng med ordtecken på en gång, istället för att testa den med flera regler och hoppa ett steg i taget beroende på att ingenting matchar.

Tips och trick
När du väl har förstått hur sammanhangsbyte fungerar blir det enkelt att skriva färgläggningsdefinitioner. Du bör ändå kontrollera noggrant vilken regel du väljer i vilken situation. Reguljära uttryck är mycket kraftfulla, men de är långsamma jämfört med andra regler. Du bör därför ta hänsyn till följande tips.
Om du bara matchar två tecken, använd Detect2Chars istället för StringDetect. Samma sak gäller för DetectChar.
Reguljära uttryck är enkla att använda, men oftast finns det ett annat mycket snabbare sätt att uppnå samma resultat. Antag att du bara vill matcha tecknet '#' om det är det första tecknet på en rad. En lösning baserad på reguljära uttryck skulle se ut så här:

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

Du kan uppnå samma sak mycket snabbare med:

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

Om du vill matcha det reguljära uttrycket '^#' kan du fortfarande använda DetectChar med egenskapen column="0". Egenskapen column räknar tecken, så en tabulator är bara ett tecken.
Du kan byta sammanhang utan att behandla tecken. Antag att du vill byta sammanhang när du stöter på strängen */, men måste behandla denna sträng i nästa sammanhang. Regeln nedan matchar, och egenskapen lookAhead gör att färgläggningen behåller den matchade strängen för nästa sammanhang.

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

Använd DetectSpaces om du vet att många blanktecken förekommer.
Använd DetectIdentifier instället för ett reguljärt uttryck '[a-zA-Z_]\w*'.
Använd standardstilar överallt du kan. På så sätt finner användaren en bekant miljö.
Titta i andra XML-filer för att se hur andra implementerade knepiga regler.
Det går att validera alla XML-filer genom att använda kommandot validatehl.sh language.xsd min-syntax.xml. Filerna validatehl.sh och language.xsd är tillgängliga i arkivet för syntaxfärgläggning.
Om du mycket ofta upprepar komplexa reguljära uttryck kan du använda ENTITETER. Till exempel:

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

Nu kan du använda &myref; istället för det reguljära uttrycket.

Skapa skript med Javascript
s editorkomponent kan enkelt utökas genom att skriva skript. Skriptspråket är ECMAscript (känt överallt som Javascript). stöder två sorters skript: intenterings- och kommandoradskript.

Indenteringsskript
Indenteringsskript, som också kallas indenterare, indenterar automatiskt källkoden medan texten skrivs in. Som ett exempel, efter att ha tryckt på returtangenten ökar ofta indenteringsnivån.
Följande avsnitt beskriver steg för steg hur skelettet för en enkel indenterare skapas. Som ett första steg, skapa en ny *.js-fil, som t.ex. heter javascript.js i den lokala hemkatalogen $XDG_DATA_HOME/katepart5/script/indentation. I detta expanderas miljövariabeln XDG_DATA_DIRS typiskt antingen som ~/.local eller ~/.local/share.
På är filerna placerade i %USER%\AppData\Local\katepart5\indentation. %USERPROFILE% expanderas oftast till C:\\Users\\användare.

Indenteringsskriptets huvud
Huvudet i filen javascript.js är inbäddat som JSON i början av dokumentet enligt följande:

var katescript = {
    "name": "JavaScript",
    "author": "Exempelnamn <exempel.namn@någon.adress.org>",
    "license": "BSD-licens",
    "revision": 1,
    "kate-version": "5.1",
    "required-syntax-style": "javascript",
    "indent-languages": ["javascript"],
    "priority": 0,
}; // kate-script-header, måste finnas i början av filen utan kommentarer

Varje post förklaras nu i detalj:
name [krävs]: Detta är indenterarens namn som visas i menyn Verktyg Indentering och i inställningsdialogrutan.
author [valfri]: Upphovsmannens namn och kontaktinformation.
license [valfri]: Kort form av licensen, såsom BSD-licensen eller LGPLv3.
revision [krävs]: Skriptets utgåva. Numret ska ökas så fort skriptet ändras.
kate-version [krävs]: Lägsta version av som krävs.
required-syntax-style [valfri]: Syntaxstilen som krävs, som matchar angiven stil i syntaxfärgläggningsfiler. Det är viktigt för indenterare som förlitar sig på specifik syntaxfärgläggningsinformation i dokumentet. Om en krävd syntaxstil specificeras, är bara indenteraren tillgänglig när lämplig syntaxfärgläggning är aktiv. Det förhindrar odefinierat beteende orsakat av att använda indenteraren utan den förväntade färgläggningsmetoden. Exempelvis använder sig Ruby-indenteraren sig av det i filen ruby.js och ruby.xml.
indent-languages [valfri]: JSON-fält av syntaxstilar som indenteraren kan indentera korrekt, t.ex. ["c++", "java"].
priority [valfri]: Om flera indenterare är lämpliga för en viss färglagd fil, bestämmer prioriteten vilken indenterare som väljes som standardindenterare.

Indenteringens källkod
Efter att ha specificerat huvudet, förklarar det här avsnittet hur själva indenteringsskriptet fungerar. Det grundläggande skelettet för implementeringen ser ut så här:

// nödvändiga katepart js bibliotek, t.ex. range.js om Range används
require ("range.js");

triggerCharacters = "{}/:;";
function indent(line, indentWidth, ch)
{
    // anropas för varje nyrad (ch == '\n') och alla tecken angivna i
    // den globala variabeln triggerCharacters. Vid anrop av VerktygJustera
    // är variabeln ch tom, dvs. ch == ''.
    //
    // se också: Programmeringsgränssnittet för skripthantering
    return -2;
}

Funktionen indent() har tre parametrar:
line: raden som ska indenteras
indentWidth: indenteringsbredden i antal mellanslag
ch: antingen ett nyradstecken (ch == '\n'), avtryckartecknet angivet i triggerCharacters eller tom om användaren utförde åtgärden Verktyg Justera.
Returvärdet från funktionen indent() anger hur raden kommer att indenteras. Om returvärdet är ett enkelt heltal, tolkas det på följande sätt:
returvärde -2: gör ingenting
returvärde -1: behåll indentering (söker efter föregående icke tomma rad)
returvärde 0: tal >= 0 anger indenteringsdjupet i mellanslag
Som alternativ kan ett fält med två element returneras.
return [ indent, align ];
I detta fall är det först elementet indenteringsdjupet ovan med samma betydelse för specialvärden. Det andra elementet är dock ett absolutvärde som representerar en kolumn för justering. Om värdet är större än indenteringsvärdet, representerar skillnaden ett antal mellanslag att lägga till efter indentering av den första parametern. Annars ignoreras det andra numret. Att använda tabulator och mellanslag för indentering kallas ofta blandat läge.
Betrakta följande exempel: Antag att tabulator används för indentering, och tabulatorbredden är inställd till 4. Här representerar <tab> en tabulator, och '.' ett mellanslag.

1: <tab><tab>anropa("Hej",
2: <tab><tab>......."allesamman");

Vid indentering av rad 2, returnerar funktionen indent() [8, 15]. Som resultat infogas två tabulatorer för att indentera till kolumn 8, och 7 mellanslag läggs till för att justera den andra parametern under den första, så att den förblir justerad om filen visas med en annan tabulatorbredd.
En standardinstallation av levererar med flera indenterare. Den motsvarande Javascript-koden finns i $XDG_DATA_DIRS/katepart5/script/indentation.
På är filerna placerade i %USER%\AppData\Local\katepart5\indentation. %USER% expanderas oftast till C:\\Users\\användare.
Att utveckla en indenterare kräver att skript läses in igen för att se om ändringar beter sig lämpligt. Istället för att starta om programmet, byt helt enkelt till kommandoraden och utför kommandot reload-scripts.
Om du utvecklar användbara skript, fundera på att bidra med det till -projektet genom att kontakta e-postlistan.

Kommandoradskript
Eftersom det är svårt att uppfylla allas behov, stöder små hjälpverktyg för snabb textbehandling via den inbyggda kommandoraden. Exempelvis är kommandot sort implementerat som ett skript. Det här avsnittet förklarar hur man skapar *.js-filer för att utöka med godtyckliga hjälpskript.
Kommandoradskript är placerade i samma katalog som indenteringsskript. Som ett första steg, skapa alltså en ny *.js-fil som heter mina_verktyg.js i den lokala hemkatalogen $XDG_DATA_HOME/katepart5/script/commands. I detta expanderas miljövariabeln XDG_DATA_DIRS typiskt antingen som ~/.local eller ~/.local/share.
På är filerna placerade i %USER%\AppData\Local\katepart5\commands. %USER% expanderas oftast till C:\\Users\\användare.

Kommandoradskriptets huvud
Huvudet för varje kommandoradskript är inbäddat som JSON i början av skriptet enligt följande:

var katescript = {
    "author": "Exempelnamn <exempel.namn@någon.adress.org>",
    "license": "LGPLv2+",
    "revision": 1,
    "kate-version": "5.1",
    "functions": ["sort", "moveLinesDown"],
    "actions": [
        {  "function": "sort",
            "name": "Sortera markerad text",
            "category": "Editing",
            "interactive": "false"
        },
        {   "function": "moveLinesDown",
            "name": "Flytta rader neråt",
            "category": "Editing",
            "shortcut": "Ctrl+Shift+Down",
            "interactive": "false"
        }
    ]
}; // kate-script-header, måste finnas i början av filen utan kommentarer

Varje post förklaras nu i detalj:
author [valfri]: Upphovsmannens namn och kontaktinformation.
license [valfri]: Kort form av licensen, såsom BSD-licensen eller LGPLv2.
revision [krävs]: Skriptets utgåva. Numret ska ökas så fort skriptet ändras.
kate-version [krävs]: Lägsta version av som krävs.
functions [krävs]: JSON-fält av kommandon i skriptet.
actions [valfri]: Ett JSON-fält av JSON-objekt som definierar åtgärderna som visas i programmenyn. Detaljerad information tillhandahålls i avsnittet Tilldela genvägar.
Eftersom värdet på functions är ett JSON-fält, kan ett enda skript innehålla godtyckligt antal kommandon för kommandoraden. Varje funktion är tillgänglig via s inbyggda kommandorad.

Skriptets källkod
Alla funktioner specificerade i huvudet måste implementeras i skriptet. Exempelvis måste skriptfilen i exemplet ovan implementera de två funktionerna sort och moveLinesDown. Alla funktioner har följande syntax:

// nödvändiga katepart.js bibliotek, t.ex. range.js om Range används
require ("range.js");

function <namn>(arg1, arg2, ...)
{
    // ... implementering, se också: Programmeringsgränssnittet för skripthantering
}

Argument på kommandoraden skickas till funktionen som arg1, arg2, etc. För att ge dokumentation av varje kommando, implementera helt enkelt funktionen 'help' på följande sätt:

function help(cmd)
{
    if (cmd == "sort") {
        return "Sortera markerad text.";
    } else if (cmd == "...") {
        // ...
    }
}

Att utföra help sort på kommandoraden anropar hjälpfunktionen med argumentet cmd inställd till det givna kommandot, dvs. cmd == "sort". visar därefter den returnerade texten som dokumentation för användaren. Försäkra dig om att översätta strängarna.
Att utveckla ett kommandoradskript kräver att skript läses in igen för att se om ändringar beter sig lämpligt. Istället för att starta om programmet, byt helt enkelt till kommandoraden och utför kommandot reload-scripts.

Tilldela genvägar
För att göra det möjligt att komma åt skripten i programmenyn och tilldela genvägar, måste skriptet tillhandahålla ett lämpligt skripthuvud. I exemplet ovan, visas båda funktionerna sort och moveLinesDown i menyn på grund a följande del av skripthuvudet:

var katescript = {
    ...
    "actions": [
        {   "function": "sort",
            "name": "Sortera markerad text",
            "icon": "",
            "category": "Editing",
            "interactive": "false"
        },
        {   "function": "moveLinesDown",
            "name": "Flytta rader neråt",
            "icon": "",
            "category": "Editing",
            "shortcut": "Ctrl+Shift+Down",
            "interactive": "false"
        }
    ]
};

Fälten för en åtgärd är följande:
function [krävs]: Funktionen som ska visas i menyn Verktyg Skript.
name [krävs]: Texten visas i skriptmenyn.
icon [valfri]: Ikonen visas intill texten i menyn. Alla :s ikonnamn kan användas här.
category [valfri]: Om en kategori anges, visas skriptet i en undermeny.
shortcut [valfri]: Genvägen som anges här är förvald genväg. Exempel: Ctrl+Alt+t. Se Qt:s dokumentation för ytterligare detaljinformation.
interactive [valfri]: Om skriptet kräver användarinmatning via kommandoraden, ange det här som true.
Om du utvecklar användbara skript, fundera på att bidra med det till -projektet genom att kontakta e-postlistan.

Programmeringsgränssnittet för skripthantering
Programmeringsgränssnittet för skripthantering som presenteras här är tillgängligt i alla skript, dvs. indenteringsskript och kommandon för kommandoraden. Klasserna Cursor och Range tillhandahålls av biblioteksfiler i $XDG_DATA_DIRS/katepart5/libraries. Om du vill använda dem i skriptet, vilket behöver använda vissa av funktionerna i Document eller View , inkludera det nödvändiga biblioteket med:

// nödvändiga katepart.js bibliotek, t.ex. range.js om Range används
require ("range.js");

För att utöka det vanliga skriptprogrammeringsgränssnittet med egna funktioner och prototyper, skapa helt enkelt en ny fil i :s lokala inställningskatalog $XDG_DATA_HOME/katepart5/libraries och inkludera den i skriptet med:

require ("mitt_skriptnamn.js");

På är filerna placerade i %USER%\AppData\Local\katepart5\libraries. %USER% expanderas oftast till C:\\Users\\användare.
För att utöka befintliga prototyper som Cursor eller Range, är det rekommenderade sättet inte att ändra den globala *.js-filen. Ändra istället prototypen för Cursor i Javascript efter att cursor.js har inkluderats i skriptet via require.

Markörer och intervall
Eftersom är en texteditor är alla programmeringsgränssnitt baserade på markörer och intervall om det är möjligt. En markör (Cursor) är ett enkelt par (rad, kolumn), som representerar en textposition i dokumentet. Ett intervall (Range) omfattar text från en markörs startposition till en markörs slutposition. Programmeringsgränssnittet förklaras i detalj i följande avsnitt.

Prototypen för Cursor

Cursor();

	Konstruktor. Returnerar en markör på position (0, 0).
Exempel: var cursor = new Cursor();

Cursor(int rad, int kolumn);

	Konstruktor. Returnerar en markör på position (rad, kolumn).
Exempel: var cursor = new Cursor(3, 42);

Cursor(Cursor annan);

	Kopieringskonstruktor. Returnerar en kopia av markören annan.
Exempel: var copy = new Cursor(other);

Cursor Cursor.clone();

	Returnerar en klon av markören.
Exempel: var clone = cursor.clone();

Cursor.setPosition(int rad, int kolumn);

	Ställer in markörens position till rad och kolumn.
Sedan: 4.11

bool Cursor.isValid();

	Kontrollera om markören är giltig. Markören är ogiltig om rad och/eller kolumn har värdet -1.
Exampel: var valid = cursor.isValid();

Cursor Cursor.invalid();

	Returnerar en ny ogiltig markör placerad på (-1, -1).
Exempel: var invalidCursor = cursor.invalid();

int Cursor.compareTo(Cursor annan);

	Jämför den här markören med markören annan. Returnerar
-1, om den här markören är placerad innan markören annan,
0, om båda markörerna är lika, och
+1, om den här markören är placerad efter markören annan.

bool Cursor.equals(Cursor annan);

	Returnerar sant om den här markören och markören annan är lika, annars falskt.

String Cursor.toString();

	Returnerar markören som en sträng på formen Cursor(rad, kolumn).

Prototyp för Range

Range();

	Konstruktor. Att anropa new Range() returnerar intervallet (0, 0) - (0, 0).

Range(Cursor start, Cursor slut);

	Konstruktor. Att anropa new Range(start, slut) returnerar intervallet (start, slut).

Range(int startrad, int startkolumn, int slutrad, int slutkolumn);

	Constructor. Calling new Range(startrad, startkolumn, slutrad, slutkolumn) returnerar intervallet från (startrad, startkolumn) to (startrad, slutkolumn).

Range(Range annat);

	Kopieringskonstruktor. Returnerar en kopia av intervallet annat.

Range Range.clone();

	Returnerar en klon av intervallet.
Exempel: var clone = range.clone();

bool Range.isEmpty();

	Returnerar sant om både start- och slutmarkörerna är lika.
Exempel: var empty = range.isEmpty();
Sedan: 4.11

bool Range.isValid();

	Returnerar sant om både start- och slutmarkörerna är giltiga, annars falskt.
Exempel: var valid = range.isValid();

Range Range.invalid();

	Returnerar intervallet från (-1, -1) till (-1, -1).

bool Range.contains(Cursor markör);

	Returnerar true om intervallet innehåller markörpositionen, annars false.

bool Range.contains(Range annat);

	Returnerar sant om det här intervallet innehåller intervallet annat, annars falskt.

bool Range.containsColumn(int kolumn);

	Returnerar sant om kolumn är i det halvöppna intervallet [startkolumn, slutkolumn), annars falskt.

bool Range.containsLine(int rad);

	Returnerar sant om rad är i det halvöppna intervallet [startrad, slutrad), annars falskt.

bool Range.overlaps(Range annat);

	Returnerar sant om det här intervallet och intervallet annat delar ett gemensamt område, annars falskt.

bool Range.overlapsLine(int rad);

	Returnerar sant om rad är i intervallet [startrad, slutrad], annars falskt.

bool Range.overlapsColumn(int kolumn);

	Returnerar sant om kolumn är i intervallet [startkolumn, slutkolumn], annars falskt.

bool Range.onSingleLine();

	Returnerar sant om intervallet startar och slutar på samma rad, dvs. om Range.start.line == Range.end.line.
Sedan: 4.9

bool Range.equals(Range annan);

	Returnerar sant om det här intervallet och intervallet annat är lika, annars falskt.

String Range.toString();

	Returnerar intervallet som en sträng på formen Range(Cursor(rad, kolumn), Cursor(rad, kolumn)).

Globala funktioner
Det här avsnittet listar alla globala funktioner.

Att läsa och inkludera filer

String read(String fil);

	Söker efter angiven fil relativt i förhållande till katalogen katepart/script/files och returnerar innehållet som en sträng.

void require(String fil);

	Söker efter angiven fil relativt i förhållande till katalogen katepart/script/libraries och utvärdera den. Internt skyddas require från att samma fil inkluderas flera gånger.
Sedan: 4.10

Felsökning

void debug(String text);

	Skriver ut text på standardutmatningen i terminalen som startade programmet.

Översättning
För att stödja fullständig landsanpassning, finns det flera funktioner för att översätta strängar i skript, närmare bestämt i18n, i18nc, i18np och i18ncp. Funktionerna beter sig exakt likadant som :s översättningsfunktioner.
Översättningsfunktionerna översätter strängarna de omger via :s översättningssystem till det språk som används i programmet. Strängar i skript som utvecklas i s officiella källkod extraheras automatiskt och är översättningsbara. Med andra ord, som utvecklare av behöver man inte bry dig om att extrahera och översätta meddelanden. Observera dock att översättningen bara fungerar inne i :s infrastruktur, nya strängar i skript från tredjepart som utvecklas utanför , översätts inte. Överväg därför gärna att bidra med dina skript till så att en passande översättning blir möjlig.

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

	Översätter text till språket som används av programmet. Parametrarna arg1, ... , är valfria och används för att ersätta platsmarkörerna %1, %2, etc.

void i18nc(String sammanhang, String text, arg1, ...);

	Översätter text till språket som används av programmet. Dessutom är strängen sammanhang synlig för översättare, så att de kan tillhandahålla en bättre översättning. Parametrarna arg1, ... , är valfria och används för att ersätta platsmarkörerna %1, %2, etc.

void i18np(String singularis, String pluralis, int antal, arg1, ...);

	Översätter antingen singularis eller pluralis till språket som används av programmet, beroende på angivet antal. Parametrarna arg1, ... , är valfria och används för att ersätta platsmarkörerna %1, %2, etc.

void i18ncp(String sammanhang, String singularis, String pluralis, int antal, arg1, ...);

	Översätter antingen singularis eller pluralis till språket som används av programmet, beroende på angivet antal. Dessutom är strängen sammanhang synlig för översättare, så att de kan tillhandahålla en bättre översättning. Parametrarna arg1, ... , är valfria och används för att ersätta platsmarkörerna %1, %2, etc.

Programmeringsgränssnittet för vyn
När ett skript håller på att köras, finns det en global variabel view som representerar den för närvarande aktiva editorvyn. Det följande är en lista med alla tillgängliga funktioner i View.

Cursor view.cursorPosition()

	Returnerar den nuvarande markörpositionen i vyn.

void view.setCursorPosition(int rad, int kolumn);
void view.setCursorPosition(Cursor markör);

	Ställ in den nuvarande markörpositionen till antingen (rad, kolumn) eller till den givna markören.

Cursor view.virtualCursorPosition();

	Returnerar den virtuella markörpositionen, där varje tabulator räknas som motsvarande antal mellanslag, beroende på nuvarande tabulatorbredd.

void view.setVirtualCursorPosition(int rad, int kolumn);
void view.setVirtualCursorPosition(Cursor markör);

	Ställ in den nuvarande virtuella markörpositionen till (rad, kolumn) eller till den givna markören.

String view.selectedText();

	Returnerar den markerade texten. Om ingen text är markerad, är den returnerade strängen tom.

bool view.hasSelection();

	Returnerar true om vyn har markerad text, annars false.

Range view.selection();

	Returnerar det markerade textintervallet. Det returnerade intervallet är ogiltigt om det inte finns någon markerad text.

void view.setSelection(Range intervall);

	Ställer in markerad text till angivet intervall.

void view.removeSelectedText();

	Tar bort den markerade texten. Om vyn inte har någon markerad text, händer ingenting.

void view.selectAll();

	Markerar hela texten i dokumentet.

void view.clearSelection();

	Rensar textmarkeringen utan att ta bort texten.

Programmeringsgränssnittet för dokumentet
När ett skript håller på att köras, finns det en global variabel document som representerar det för närvarande aktiva dokumentet. Det följande är en lista med alla tillgängliga funktioner i Document.

String document.fileName();

	Returnerar dokumentets filnamn eller en tom sträng för osparade textbuffrar.

String document.url();

	Returnerar dokumentets fullständiga webbadress eller en tom sträng för osparade textbuffrar.

String document.mimeType();

	Returnerar dokumentets Mime-typ eller Mime-typen application/octet-stream om ingen lämplig Mime-typ kunde hittas.

String document.encoding();

	Returnerar den nuvarande kodningen använd för att spara filen.

String document.highlightingMode();

	Returnerar det allmänna färgläggningsläget som används för hela dokumentet.

String document.highlightingModeAt(Cursor pos);

	Returnerar färgläggningsläget som används på den givna positionen i dokumentet.

Array document.embeddedHighlightingModes();

	Returnerar ett fält med färgläggningslägen inbäddade i det här dokumentet.

bool document.isModified();

	Returnerar true om dokumentet har osparade ändringar (är modifierat), annars false.

String document.text();

	Returnerar dokumentets hela innehåll i en enda textsträng. Nya rader är markerade med nyradstecknet \n.

String document.text(int från_rad, int från_kolumn, int till_rad, int till_kolumn);
String document.text(Cursor från, Cursor till);
String document.text(Range intervall);

	Returnerar texten i det angivna intervallet. Det rekommenderas att använda markör- och intervallbaserade versioner för bättre läsbarhet hos källkoden.

String document.line(int rad);

	Returnerar den givna textraden som en sträng. Strängen är tom om den begärda raden är utanför tillgängligt intervall.

String document.wordAt(int rad, int kolumn);
String document.wordAt(Cursor markör);

	Returnerar ordet på den angivna markörposition.

Range document.wordRangeAt(int rad, int kolumn);
Range document.wordRangeAt(Cursor markör);

	Returnerar intervallet för ordet på den givna markörpositionen. Det returnerade intervallet är ogiltigt (se Range.isValid()) om textpositionen är efter ett radslut. Om det inte finns något ord vid den givna markörpositionen returneras ett tomt intervall.
Sedan: 4.9

String document.charAt(int rad, int kolumn);
String document.charAt(Cursor markör);

	Returnerar tacknet på den angivna markörpositionen.

String document.firstChar(int rad);

	Returnerar det första tecknet på angiven rad som inte är ett blanktecken. Det första tecknet finns på kolumn 0. Om raden är tom, eller bara innehåller blanktecken, är den returnerade strängen tom.

String document.lastChar(int rad);

	Returnerar det sista tecknet på angiven rad som inte är ett blanktecken. Om raden är tom, eller bara innehåller blanktecken, är den returnerade strängen tom.

bool document.isSpace(int rad, int kolumn);
bool document.isSpace(Cursor markör);

	Returnerar sant om tecknet på den givna markörpositionen är ett blanktecken, annars falskt.

bool document.matchesAt(int rad, int kolumn, String text);
bool document.matchesAt(Cursor markör, String text);

	Returnerar sant om given text matchar på den motsvarande markörpositionen, annars falskt.

bool document.startsWith(int rad, String text, bool hoppa_över_blanktecken);

	Returnerar sant om raden börjar med text, annars falskt. Argumentet hoppa_över_blanktecken bestämmer om inledande blanktecken ignoreras.

bool document.endsWith(int rad, String text, bool hoppa_över_blanktecken);

	Returnerar sant om raden slutar med text, annars falskt. Argumentet hoppa_över_blanktecken bestämmer om inledande blanktecken ignoreras.

bool document.setText(String text);

	Anger hela dokumentets text.

bool document.clear();

	Tar bort hela texten i dokumentet.

bool document.truncate(int rad, int kolumn);
bool document.truncate(Cursor markör);

	Avkortar den givna raden på den givna kolumnen eller markörpositionen. Returnerar sant om det lyckas, eller falskt om den givna raden inte ingår i dokumentets intervall.

bool document.insertText(int rad, int kolumn, String text);
bool document.insertText(Cursor markör, String text);

	Infogar text på den givna markörpositionen. Returnerar sant om det lyckas, eller falskt om dokumentet är skrivskyddat.

bool document.removeText(int från_rad, int från_kolumn, int till_rad, int till_kolumn);
bool document.removeText(Cursor från, Cursor till);
bool document.removeText(Range intervall);

	Tar bort text i det givna intervallet. Returnerar sant om det lyckas, eller falskt om dokumentet är skrivskyddat.

bool document.insertLine(int rad, String text);

	Infogar text på den givna raden. Returnerar sant om det lyckas, eller falskt om dokumentet är skrivskyddat eller raden inte ingår i dokumentets intervall.

bool document.removeLine(int rad);

	Tar bort den givna textraden. Returnerar sant om det lyckas, eller falskt om dokumentet är skrivskyddat eller raden inte ingår i dokumentets intervall.

bool document.wrapLine(int rad, int kolumn);
bool document.wrapLine(Cursor markör);

	Radbryter raden vid den givna markörpositionen. Returnerar sant om det lyckas, eller falskt, t.ex. om rad < 0.
Sedan: 4.9

void document.joinLines(int startrad, int slutrad);

	Sammanfogar rader från startrad till slutrad. Två på varandra följande rader åtskiljs alltid med exakt ett mellanslag.

int document.lines();

	Returnerar antal rader i dokumentet.

bool document.isLineModified(int rad);

	Returnerar sant om rad för närvarande innehåller osparad data.
Since: 5.0

bool document.isLineSaved(int rad);

	Returnerar sant om rad har ändrats, men dokumentet har sparats. Sålunda innehåller raden för närvarande ingen osparad data.
Since: 5.0

bool document.isLineTouched(int rad);

	Returnerar sant om rad för närvarande innehåller osparad data eller tidigare har ändrats.
Since: 5.0

bool document.findTouchedLine(int startrad, bool ner);

	Sök efter nästa ändrade rad med början på rad. Sökningen utförs antingen uppåt eller neråt beroende på sökriktningen angiven med ner.
Since: 5.0

int document.length();

	Returnerar antal tecken i dokumentet.

int document.lineLength(int rad);

	Returnerar längden på rad.

void document.editBegin();

	Startar en redigeringsgrupp för gruppering av ångra/gör om. Försäkra dig om att alltid anropa editEnd() lika många gånger som du anropar editBegin(). Att anropa editBegin() använder en referensräknare internt, dvs. anropet kan nästlas.

void document.editEnd();

	Avslutar en redigeringsgrupp. Det sista anropet av editEnd() (dvs. det för det första anropet till editBegin()) avslutar redigeringssteget.

int document.firstColumn(int rad);

	Returnerar det första tecknet som inte är ett blanktecken på given rad. Om det bara finns blanktecken på raden, är returvärdet -1.

int document.lastColumn(int rad);

	Returnerar det sista tecknet som inte är ett blanktecken på given rad. Om det bara finns blanktecken på raden, är returvärdet -1.

int document.prevNonSpaceColumn(int rad, int kolumn);
int document.prevNonSpaceColumn(Cursor markör);

	Returnerar kolumnen med ett tecken som inte är ett blanktecken med början på given markörposition genom att söka bakåt.

int document.nextNonSpaceColumn(int rad, int kolumn);
int document.nextNonSpaceColumn(Cursor markör);

	Returnerar kolumnen med ett tecken som inte är ett blanktecken med början på given markörposition genom att söka framåt.

int document.prevNonEmptyLine(int rad);

	Returnerar nästa rad som inte är tom och som innehåller tecken som inte är blanktecken, genom att söka bakåt.

int document.nextNonEmptyLine(int rad);

	Returnerar nästa rad som inte är tom och som innehåller tecken som inte är blanktecken, genom att söka framåt.

bool document.isInWord(String tecken, int egenskap);

	Returnerar sant, om givet tecken med given egenskap kan vara en del av ett ord, annars falskt.

bool document.canBreakAt(String tecken, int egenskap);

	Returnerar sant, om givet tecken med given egenskap är lämpat att bryta en rad, annars falskt.

bool document.canComment(int startegenskap, int slutegenskap);

	Returnerar sant om ett intervall som börjar och slutar med den givna egenskapen är lämpat att kommenteras bort, annars falskt.

String document.commentMarker(int egenskap);

	Returnerar kommentarmarkören för enraderskommentarar för en given egenskap.

String document.commentStart(int egenskap);

	Returnerar kommentarmarkören för början av flerraderskommentarer för en given egenskap.

String document.commentEnd(int egenskap);

	Returnerar kommentarmarkören för slutet av flerraderskommentarer för en given egenskap.

Range document.documentRange();

	Returnerar ett intervall som omfattar hela dokumentet.

Cursor documentEnd();

	Returnerar en markör placerad på den sista radens sista kolumn i dokumentet.

bool isValidTextPosition(int rad, int kolumn);
bool isValidTextPosition(Cursor markör);

	Returnerar sant om den angivna markörpositionen är placerad på en giltig textposition. En textposition är bara giltig om den finns i början av, mitten av eller slutet av en giltig rad. Dessutom är en textposition ogiltig om den är placerad i ett Unicode-surrogat.
Since: 5.0

int document.attribute(int rad, int kolumn);
int document.attribute(Cursor markör);

	Returnerar egenskapen på den angivna markörpositionen.

bool document.isAttribute(int rad, int kolumn, int egenskap);
bool document.isAttribute(Cursor markör, int egenskap);

	Returnerar sant om egenskapen på den givna markörpositionen är lika med egenskap, annars falskt.

String document.attributeName(int rad, int kolumn);
String document.attributeName(Cursor markör);

	Returnerar egenskapsnamnet som läsbar text. Det är lika med namnet itemData i syntaxfärgläggningsfilerna.

bool document.isAttributeName(int rad, int kolumn, String namn);
bool document.isAttributeName(Cursor markör, String namn);

	Returnerar sant om egenskapsnamnet på en viss markörposition motsvara givet namn, annars falskt.

String document.variable(String nyckel);

	Returnerar värdet på den begärda dokumentvariabeln nyckel. Om dokumentvariabeln inte finns, är returvärdet en tom sträng.

void document.setVariable(String nyckel, String värde);

	Ställ in värdet på den begärda dokumentvariabeln nyckel.
Se också: Kate-dokumentvariabler
Sedan: 4.8

int document.firstVirtualColumn(int rad);

	Returnerar den virtuella kolumnen för det första tecknet som inte är ett blanktecken på den givna raden, eller -1 om raden är tom eller bara innehåller blanktecken.

int document.lastVirtualColumn(int rad);

	Returnerar den virtuella kolumnen för det sista tecknet som inte är ett blanktecken på den givna raden, eller -1 om raden är tom eller bara innehåller blanktecken.

int document.toVirtualColumn(int rad, int kolumn);
int document.toVirtualColumn(Cursor markör);
Cursor document.toVirtualCursor(Cursor markör);

	Konverterar den givna verkliga markörpositionen till en virtuell markörposition, och returnerar antingen ett heltal eller ett markörobjekt.

int document.fromVirtualColumn(int rad, int virtuell_kolumn);
int document.fromVirtualColumn(Cursor virtuell_markör);
Cursor document.fromVirtualCursor(Cursor virtuell_markör);

	Konverterar den givna virtuella markörpositionen till en verklig markörposition, och returnerar antingen ett heltal eller ett markörobjekt.

Cursor document.anchor(int rad, int kolumn, Char tecken);
Cursor document.anchor(Cursor markör, Char tecken);

	Söker bakåt efter det givna tecknet med början på den givna markören. Om exempelvis '(' anges som tecken, returnerar funktionen positionen på ett inledande '('. Det sker med referensräkning, dvs. andra '(...)' ignoreras.

Cursor document.rfind(int rad, int kolumn, String text, int egenskap = -1);
Cursor document.rfind(Cursor markör, String text, int egenskap = -1);

	Söker bakåt efter den givna texten med lämplig egenskap. Argumentet egenskap ignoreras om det anges som -1. Den returnerade markören är ogiltig om texten inte kunde hittas.

int document.defStyleNum(int rad, int kolumn);
int document.defStyleNum(Cursor markör);

	Returnerar standardstilen som används på den givna markörpositionen.

bool document.isCode(int rad, int kolumn);
bool document.isCode(Cursor markör);

	Returnerar sant om egenskapen på given markörposition inte är lika med någon av följande stilar: dsComment, dsString, dsRegionMarker, dsChar, dsOthers.

bool document.isComment(int rad, int kolumn);
bool document.isComment(Cursor markör);

	Returnerar sant, om egenskapen för tecknet på markörpositionen är dsComment, annars falskt.

bool document.isString(int rad, int kolumn);
bool document.isString(Cursor markör);

	Returnerar sant, om egenskapen för tecknet på markörpositionen är dsString, annars falskt.

bool document.isRegionMarker(int rad, int kolumn);
bool document.isRegionMarker(Cursor markör);

	Returnerar sant, om egenskapen för tecknet på markörpositionen är dsRegionMarker, annars falskt.

bool document.isChar(int rad, int kolumn);
bool document.isChar(Cursor markör);

	Returnerar sant, om egenskapen för tecknet på markörpositionen är dsChar, annars falskt.

bool document.isOthers(int rad, int kolumn);
bool document.isOthers(Cursor markör);

	Returnerar sant, om egenskapen för tecknet på markörpositionen är dsOthers, annars falskt.