# Udvikling af plugin for &krita;

## Indledning

&krita; kan udvides i det uendelige med plugin. Værktøjer, filtre, store dele af brugergrænsefladen og alle farverum er plugin. I virkeligheden genkender &krita; følgende seks typer plugin:

- farverum — disse definerer kanalerne som udgør et enkelt billedpunkt

- værktøjer — alt som udføres med en mus eller styreplade

- maleoperationer — maleeffekter for værktøjer som kan indlæses

- billedfiltre — ændr alle billedpunkter, eller kun markerede billedpunkter i et lag

- visningsplugin — udvider Kritas brugergrænseflade med nye dialoger, paletter og handlinger

- import- og eksportfiltre — læs og skriv alle slags billedformater

Selve &krita; består af tre biblioteker i lag og en mappe med visse fælles støtteklasser: kritacolor, kritaimage og kritaui. Inde i &krita; kan objekter identificeres af en `KisID`, som er en kombinationen af en entydig uoversat streng (som for eksempel bruges når noget skal gemmes) og en øversat streng beregnet til den grafiske brugergrænseflade.

Et ord om kompatibilitet: &krita; er stadigvæk under udvikling. Fra &krita; 1.5 til 1.6 forventes ikke mange ændringer af programmeringsgrænsefladen, men der kan være nogle. Fra &krita; 1.6 til 2.0 skifter vi fra &Qt; 3 til &Qt; 4, fra &kde; 3 til &kde; 4 og fra `automake` til `cmake`: mange ændringer kan forventes. Hvis du udvikler et plugin for &krita; og vælger at gøre det i &krita;s subversion-arkiv, er der udmærkede muligheder for at vi hjælper dig med overførslen. Ændringerne kan også gøre at visse dele af dette dokument bliver forældede. Tjek altid den seneste dokumentation af programmeringsgrænsefladen eller deklarationsfilerne som er installerede på dit system.

### KritaColor

Det første bibliotek er kritacolor. Dette bibliotek indlæser farverumsplugin.

Et farverumsplugin skal implementere den abstrakte klasse `KisColorSpace`, eller hvis de grundlæggende funktioner i det nye farverum implementeres af `lcms` (), udvide `KisAbstractColorSpace`. Biblioteket kritacolor kan bruges fra andre program, og afhænger ikke af &koffice;.

### KritaImage

Biblioteket libkritaimage indlæser filter- og maleoperationsplugin, og er ansvarligt for at arbejde med billeddata: ændre billedpunkter, sammensætte og male. Pensler, paletter, toninger og mønstre indlæses også af libkritaimage. Det er et udtalt mål at gøre libkritaimage uafhængig af &koffice;, men for øjeblikket deler vi koden til at indlæse toninger med &koffice;.

Det er for øjeblikket ikke nemt at tilføje nye typer af ressourcer såsom pensler, paletter, toninger eller mønstre i &krita;. (At tilføje nye pensler, paletter, toninger og mønstre er naturligvis enkelt.) &krita; følger anvisningerne fra projektet Create () for disse. At tilføje understøttelse for Photoshops penselfilformat kræver kodning i libkritaimage. At tilføje flere penseldatafiler fra Gimp kræver ikke dette.

`KritaImage` indlæser følgende plugintyper:

- Filter i &krita; skal udvide og implementere den abstrakte klasse `KisFilter`, `KisFilterConfiguration` og muligvis `KisFilterConfigurationWidget`. Et eksempel på et filter er Uskarp maske.

- Maleoperationer er det sæt af operationer som maleværktøjer såsom frihånd eller cirkel har adgang til. Eksempel på maleoperationer er pen, retuschsprøjte eller viskelæder. Maleoperationer skal udvide basisklassen `KisPaintop`. Eksempel på nye maleoperationer kunne være en kridtbørste, en pensel til oliemaling eller en kompleks programmerbar pensel.

### KritaUI

Biblioteket libkritaui indlæser værktøjet og visningsplugin. Dette bibliotek er et &koffice;-partprogram, men indeholder også et antal grafiske kontroller som er nyttige i grafikprogrammer. Måske skal dette bibliotek deles i kritapart og kritaui for udgave 2.0. For øjeblikket gives forfattere af scripter ikke adgang til dette bibliotek og forfattere af plugin tillades kun at bruge dette bibliotek når værktøerj og visningsplugin skrives. `KritaUI` indlæser følgende plugintyper:

- Værktøjer afledes fra `KisTool` eller en af de specialiserede værktøjsbasisklasser såsom `KisToolPaint`, `KisToolNonPaint` eller `KisToolFreehand`. Et nyt værktøj kunne være et værktøj til markering af forgrunden. Maleværktøjer (og det omfatter værktøjer som maler på markeringen) kan bruge en hvilken som helst maleoperation til at bestemme hvordan billedpunkter ændres.

- Visningsplugin er sædvanlige KParts, som bruger `kxmlgui` til at indlejre sig i &krita;s brugergrænseflade. Menupunkter, dialoger, værktøjslinjer — alle slags udvidelser af brugergrænsefladen kan være visningsplugin. I virkeligheden er vigtige funktioner, såsom &krita;s understøttelse for scripter, skrevet som visningsplugin.

### Import- og eksportfiltre

Import- og eksportfiltre er &koffice;-filter, delklasser af `KoFilter`. Filtre læser og skriver billeddata på et af de utroligt mange billedformater som eksisterer. Et eksempel på et nyt import- og eksportfiler for &krita; kunne være et PDF-filter. Filtre indlæses af &koffice;-bibliotekerne.

## Opret plugin

Plugin skrives i C++ og kan bruge hele programmeringsgrænsefladen i &kde; og &Qt; samt &krita;s udviklingsgrænseflade. Kun visningsplugin skal bruge &koffice;' programmeringsgrænseflade. Du skal ikke bekymre dig, &krita;s programmeringsgrænseflade er meget ren og relativt udførligt dokumenteret (af frit programmel at være) og at kode dit første filter er meget nemt.

Hvis du ikke vil bruge C++ kan du skrive scripter i Python eller Ruby: det er dog en helt anden sag, og du kan for øjeblikket ikke skrive værktøjer, farverum, maleoperationer eller import- og eksportfilter som scripter.

Plugin i &krita; bruger &kde;'s mekanisme for partprogrammer til indlæsning, så dokumentationen om partprogrammer på er også relevant her.

Relevante deklarationsfiler skal enten være installeret med selve &krita; af din distribution, eller også er deklarationsfilerne måske enten lagt i pakken &koffice;-dev eller i &krita;-dev. Du finder dokumentationen af &krita;s eksterne programmeringsgrænseflade på .

### Automake (og CMake)

&kde; 3.x og derfor også &koffice; 1.5 og 1.6 bruger `automake`. &kde; 4.0 og &koffice; 2.0 bruger `cmake`. Denne gennemgang beskriver måden at oprette plugin som bruger `automake`.

Plugin er &kde;-moduler, og skal markeres som sådanne i `Makefile.am`. Filtre, værktøjer, maleoperationer, farverum samt import- og eksportfiltre har brug for `.desktop`-filer. Visningsplugin har desuden brug for en KXMLGui `pluginname.rc`-fil. Den nemmeste måde at komme i gang er at tjekke projektet krita-plugins ud fra &koffice; Subversion-arkiv og bruge det som basis for dit eget projekt. Vi har til hensigt at oprette en pakke med en &krita; pluginskabeloner for Kdevelop, men har ikke fået tid til at gøre det endnu.

#### `Makefile.am`

Lad os tage et kig på skabelonen for et plugin-modul. Først filen `Makefile.am`. Det er den &kde; bruger til at oprette byggefilen som bygger dit plugin:

    kde_services_DATA = kritaBIBLIOTEKSNAVN.desktop

    INCLUDES = $(all_includes)

    kritaBIBLIOTEKSNAVN_la_SOURCES = sourcefile1.cc sourcefile2.cc

    kde_module_LTLIBRARIES = kritaBIBLIOTEKSNAVN.la
    noinst_HEADERS = header1.h header2.h

    kritaBIBLIOTEKSNAVN_la_LDFLAGS = $(all_libraries) -module $(KDE_PLUGIN)
    kritaLIBRARY_la_LIBADD = -lkritacommon

    kritaextensioncolorsfilters_la_METASOURCES = AUTO

Dette er byggefilen for et filter-plugin. Erstat `BIBLIOTEKSNAVN` med navnet på dit arbejde, så er du klar.

Hvis dit plugin er et visningsplugin, installerer du formodentlig også en `.rc`-fil med indgange for menulinjer og værktøjslinjer. På lignende måde skal du måske også installere markører og ikoner. Alt dette gøres via de magiske besværgelser i &kde;'s sædvanlige `Makefile.am`.

    kritarcdir = $(kde_datadir)/krita/kritaplugins
    kritarc_DATA = BIBLIOTEKSNAVN.rc
    EXTRA_DIST = $(kritarc_DATA)

    kritapics_DATA = \
       bla.png \
       bla_cursor.png
    kritapicsdir = $(kde_datadir)/krita/pics

#### Desktopfiler

Filen `.desktop` fortæller pluginnets type:

    [Desktop Entry]
    Encoding=UTF-8
    Icon=
    Name=User-visible Name
    ServiceTypes=Krita/Filter
    Type=Service
    X-KDE-Library=kritaBIBLIOTEKSNAVN
    X-KDE-Version=2

Mulige tjenestetyper er:

- Krita/Filter

- Krita/Paintop

- Krita/ViewPlugin

- Krita/Tool

- Krita/ColorSpace

Import- og eksportfiltre for filer bruger det generelle filterskelet i &koffice; og må beskrives separat.

#### Standardkode

Du behøver også en del standardkode som kaldes af &kde;'s skelet for partprogrammer for at instantiere pluginnet — en deklarationsfil og en implementeringsfil.

En deklarationsfil:

    #ifndef TOOL_STAR_H_
    #define TOOL_STAR_H_

    #include <kparts/plugin.h>

    /**
    * En modul som sørger for et stjerneværktøj.
    */
    class ToolStar : public KParts::Plugin
    {
       Q_OBJECT
    public:
       ToolStar(QObject *parent, const char *name, const QStringList &);
       virtual ~ToolStar();

    };

    #endif // TOOL_STAR_H_

Og en implementeringsfil:

    #include <kinstance.h>
    #include <kgenericfactory.h>

    #include <kis_tool_registry.h>

    #include "tool_star.h"
    #include "kis_tool_star.h"

    typedef KGenericFactory<ToolStar> ToolStarFactory;
    K_EXPORT_COMPONENT_FACTORY( kritatoolstar, ToolStarFactory( "krita" ) )

    ToolStar::ToolStar(QObject *parent, const char *name, const QStringList &)
       : KParts::Plugin(parent, name)
    {
       setInstance(ToolStarFactory::instance());
       if ( parent->inherits("KisToolRegistry") )
       {
           KisToolRegistry * r = dynamic_cast<KisToolRegistry*>( parent );
           r -> add(new KisToolStarFactory());
       }

    }

    ToolStar::~ToolStar()
    {
    }

    #include "tool_star.moc"

#### Registre

Værktøjer indlæses af værktøjsregistret og registrerer sig selv med værktøjsregistret. Plugin såsom værktøjer, filtre og maleoperationer indlæses kun en gang. Visningsplugin indlæses for hver visning som skabes. Bemærk at vi registrerer fabriker generelt sagt. For værktøjer skabes eksempelvis en ny instans af et værktøj for hver peger (mus, pen, viskelæder), og en ny maleoperation skabes så snart et værktøj får begivenheden museklik.

Filtre kalder filterregistret:

    if (parent->inherits("KisFilterRegistry")) {
           KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
           manager->add(new KisFilterInvert());
       }

Maleoperationer maleoperationsregistret:

    if ( parent->inherits("KisPaintOpRegistry") ) {
               KisPaintOpRegistry * r = dynamic_cast<KisPaintOpRegistry*>(parent);
               r -> add ( new KisSmearyOpFactory );
       }

Farverum farverumsregistret (med visse komplikationer):

    if ( parent->inherits("KisColorSpaceFactoryRegistry") ) {
            KisColorSpaceFactoryRegistry * f = dynamic_cast<isColorSpaceFactoryRegistry*>(parent);

           KisProfile *defProfile = new KisProfile(cmsCreate_sRGBProfile());
           f->addProfile(defProfile);

           KisColorSpaceFactory * csFactory = new KisRgbColorSpaceFactory();
           f->add(csFactory);

           KisColorSpace * colorSpaceRGBA = new KisRgbColorSpace(f, 0);
           KisHistogramProducerFactoryRegistry::instance() -> add(
                   new KisBasicHistogramProducerFactory<KisBasicU8HistogramProducer>
                   (KisID("RGB8HISTO", i18n("RGB8 Histogram")), colorSpaceRGBA) );
       }

Visningsplugin har ikke noget eget register, og de får adgang til et objekt af klassen `KisView`:

    if ( parent->inherits("KisView") )
       {
           setInstance(ShearImageFactory::instance());
           setXMLFile(locate("data","kritaplugins/shearimage.rc"), true);

           (void) new KAction(i18n("&Shear Image..."), 0, 0, this, SLOT(slotShearImage()), actionCollection(), "shearimage");
           (void) new KAction(i18n("&Shear Layer..."), 0, 0, this, SLOT(slotShearLayer()), actionCollection(), "shearlayer");

           m_view = (KisView*) parent;
       }

Husk at dette betyder at et visningsplugin skabes for hver visning som brugeren laver: at opdele en visning betyder at alle visningsplugin indlæses igen.

#### Versionshåndtering af plugin

&krita; 1.5 indlæser plugin med `X-KDE-Version=2` angivet i `.desktop`-filen. &krita; 1.6 kommer formodentlig ikke til at være binært kompatibel med 1.5 plugin og vil behøve versionsnumret 3. &krita; 2.0 plugin kommer til at behøve versionsnumret 3. Ja, det er ikke helt logisk.

## Farverum

Farverum implementerer den rent virtuelle klasse `KisColorSpace`. Der er to typer af farverum: de som kan bruge `lcms` til overførsler mellem farverum, og de som er for mærkelige for `lcms` at håndtere. Eksempel på de første er cmyk, rgb, yuv. Et eksempel på den senere er watercolor eller wet & sticky. Farverum som bruger `lcms` kan afledes fra `KisAbstractColorSpace` eller en af basisklasserne som er specialiserede til et vist antal bit per kanal.

Det er ganske enkelt at implementere et farverum. Det generelle princip er at farverum arbejder med et enkelt felt af byte. Tolkningen af disse bestemmes af farverummet selv. For eksempel består et billedpunkt i 16-bit GrayA af fire byte: to for gråskalaværdien og to for alfaværdien. Du er fri til at bruge en struct til at arbejde med hukommelseslayouten af et billedpunkt i din implementering af farverum, men den repræsentationen eksporteres ikke. Den eneste måde som resten af &krita; kan vide hvilke kanaler og typer af kanaler din farverums billedpunkter består af er via klassen `KisChannelInfo`.

Filtre og maleoperationer udnytter den omfattande mængde metoder som der sørges for af `KisColorSpace` til at udføre sit arbejde. I mange tilfælde fungerer standardimplementeringen i `KisAbstractColorSpace` men langsommere end en egen implementering i dit eget farverum, eftersom `KisAbstractColorSpace` konverterer alle billedpunkter til 16-bit L*a*b og tilbage.

### `KisChannelInfo`

    (http://websvn.kde.org/trunk/koffice/krita/kritacolor/kis_channelinfo.h)

Denne klasse definerer kanalerne som udgør et enkelt billedpunkt i et bestemt farverum. En kanal har følgende vigtige egenskaber:

- et navn på en skærm i brugergrænsefladen

- en position: den byte hvor alle de byte som repræsenterer kanalen begynder i billedpunktet.

- en type: farve, alfa, substans eller substrat. Farve er sædvanlig farve, alfa er gennemsigtighed, substans er en repræsentation af mængden af pigment eller lignende ting, substrat er en repræsentation af kanvassen. (Bemærk at dette kan ændres meget hurtigt hvis det ønskes.)

- en værditype: byte, short, integer, float — eller noget andet.

- størrelse: antal byte som kanalen optager

- farve: en repræsentation med `QColor` af kanalen for visualisering i brugergrænseflade, for eksempel i histogrammer.

- en forkortelse at bruge i den grafiske brugergrænseflade når der ikke er meget plads

### `KisCompositeOp`

Ligesom for den oprindelige Porter-Duff, er der mange måder at kombinere billedpunkter for at få en ny farve. Klassen `KisCompositeOp` definerer de fleste af dem: Dette sæt kan ikke enkelt udvides undtagen ved at ændre kode i biblioteket kritacolor.

Et farverumsplugin kan understøtte en hvilken som helst delmængde af de mulige sammensætningsoperationer, men sættet skal altid omfatte "OVER" (samme som "NORMAL") og "COPY". De øvrige er mere eller mindre valgfrie, selvom flere naturligvis er bedre.

### `KisColorSpace`

Metoderne i den rent virtuelle klasse `KisColorSpace` kan deles op i et antal grupper: konvertering, identifikation og behandling.

Alle klasser skal kunne konvertere et billedpunkt fra og til 8-bit RGB (dvs. en `QColor`), og helst også til og fra 16-bit L*a*b*. Desuden er der en metode til at konvertere til et hvilket som helst andet farverum fra det nuværende farverum.

Farverum beskrives af vektoren `KisChannelInfo`, antal kanaler, antal byte i et enkelt billedpunkt, om det understøtter billeder med stort dynamisk område, med mere.

Behandling er for eksempel at kombinere to billedpunkter til et nyt billedpunkt: bitBlt, at gøre billedpunkter mørkere eller foldning af billedpunkter.

Kig i dokumentationen af programmeringsgrænsefladen for en fuldstændig beskrivelse af alle metoder du skal implementere i en farverum.

`KisAbstractColorSpace` implementerer mange af de virtuelle metoder i `KisColorSpace` ved brug af funktioner fra biblioteket `lcms`. Ovenpå `KisAbstractColorSpace` er der basisklasser for farverum med 8- og 16-bit heltal samt 16- og 32-bit float som definerer fælles operationer for at flytte mellem bitdybder.

## Filtre

Filtre er plugin som undersøger billedpunkter i et lag og derefter udfører ændringer af dem. Selvom &krita; bruger en effektiv hukommelsesgrænseflade baseret på tiles til at opbevare billedpunkter, skalforfattere af filtre ikke bekymre sig om det. Når et filterplugin skrives for billedbehandlingsgrænsefladen i &Java;, Photoshop eller Gimp skal man sørge for at tile-kanter og sammenkoble tiles med hinanden. &krita; skjuler alle sådanne implementeringsdetaljer.

Bemærk at det teoretisk er nemt at erstatte den nuværende grænseflade for dataopbevaring baseret på tiles med en andet grænseflade, men at denne grænseflade af ydelsesgrunde for øjeblikket ikke er rigtige plugin.

&krita; bruger interatorer til at læse og skrive billedpunktværdier. Alternativt kan du indlæse en blok med billedpunkter i en hukommelsesbuffer, arbejde med den og derefter skrive den tilbage som en blok. Dette er dog ikke nødvendigvis effektivere, men kan til og med være langsommere end at bruge iteration: det er måske blot bekvemmere. Se dokumentationen af programmeringsgrænsefladen.

Billeder i &krita; består af lag, hvoraf der for øjeblikket findes fire slags: malelag, gruppelag, justeringslag (som indeholder et filter som dynamisk bruges for lag under justeringslaget) og part-lag. Filtre arbejder altid med malelag. Malelag indeholder maleenheder af klassen `KisPaintDevice`. En maleenhed giver på sin side mulighed for at få adgang til selve billedpunkterne.

En `PaintDevice` sendes generelt rundt indlejret i en delt peger. En delt peger holder styr på hvor mange steder som maleenheden for øjeblikket bruges, og fjerner maleenheden når den ikke længere bruges nogen steder. Du genkender versionen af en maleenhed med en delt peger på dens suffix `SP`. Husk blot at du aldrig eksplicit behøver at fjerne en `KisPaintDeviceSP`.

Lad os undersøge et meget enkelt filter, et som inverterer alle billedpunkter. Koden for filtret findes i mappen `koffice/krita/plugins/filters/example`. Hovedmetoden er:

    KisFilterInvert::process(KisPaintDeviceSP src, KisPaintDeviceSP dst,
                            KisFilterConfiguration* /*config*/, const QRect& rect).

Funktionen modtager to maleenheder, et indstillingsobjekt (som ikke bruges i dette enkle filter) og en `rect`. Denne `rect` beskriver maleenhedens område som filtret skal håndtere. Området beskrives med heltal, hvilket betyder at der ikke findes nogen nøjagtighed på delbilledpunktsniveau.

Maleenheden `src` er til for at læse fra, og maleenheden `dst` er til for at skrive til. Disse parametre kan pege på samme egentlige maleenhed, eller være to forskellige maleenheder. (Bemærk: dette vil måske blive ændret til en enkelt maleenhed i fremtiden.)

Lad os nu betragte koden linje for linje:

    void KisFilterInvert::process(KisPaintDeviceSP src, KisPaintDeviceSP dst,
                                 KisFilterConfiguration* /*config*/, const QRect& rect)
    {
       Q_ASSERT(src != 0);
       Q_ASSERT(dst != 0);

       KisRectIteratorPixel srcIt = src->createRectIterator(rect.x(), rect.y(), rect.width(), rect.height(), false);
       KisRectIteratorPixel dstIt = dst->createRectIterator(rect.x(), rect.y(), rect.width(), rect.height(), true );

       int pixelsProcessed = 0;
       setProgressTotalSteps(rect.width() * rect.height());

       KisColorSpace * cs = src->colorSpace();
       Q_INT32 psize = cs->pixelSize();

       while( ! srcIt.isDone() )
       {
           if(srcIt.isSelected())
           {
               memcpy(dstIt.rawData(), srcIt.oldRawData(), psize);

               cs->invertColor( dstIt.rawData(), 1);
           }
           setProgress(++pixelsProcessed);
           ++srcIt;
           ++dstIt;
       }
       setProgressDone(); // Skal kaldes også selvom det ikke understøttes
    }

- Dette laver en iterator til at læse eksisterende billedpunkter. Krita har tre typer af iteration: vandret, lodret og rektangulær. Iterationen rect går den effektiveste vej gennem billeddata, men garanterer ikke noget om stedet for næste billedpunkt den returnerer. Det betyder at du ikke kan være sikker på at billedpunkter du henter næste gang ligger ved siden af de billedpunkter du netop modtot. De vandrette og lodrette iterationer garanterer virkelig stedet for de billedpunkter de returnerer.

- Vi laver destinationsiteratoren med værdien `true` for indstillingen `write`. Det betyder at hvis destinationens malesenhed er mindre end rektanglen vi skriver, forstørres den automatisk til at omfatte alle billedpunkter i iterationen. Bemærk at vi har et potentiel fejl her: hvis `dst` og `src` ikke er samme enhed er det meget muligt at billedpunkterne som iteratorerne returnerer ikke svarer til hinanden. For hver position i iteratoren kan `src` for eksempel være 165, 200, mens `dst` ville kunne være 20, 8 — og derfor vil kopien vi laver nedenfor kunne forvrænge billedet ...

- Vil du vide om et billedpunkt er markeret? Det er nemt: brug metoden `isSelected`. Men at være markeret er ikke en binær egenskab for et billedpunkt. Et billedpunkt kan være halvmarkeret, næsten umarkeret, eller næsten helt markeret. Markeringer er i virkeligheden en maskemaleenhed med området 0 til 255, hvor 0 er helt umarkeret og 255 helt markeret. Iteratoren har to metoder: `isSelected()` og `selectedNess()`. Den første returnerer sand hvis et billedpunkt overhovedet er markeret (dvs. maskeværdien er større end 1), den anden returnerer maskeværdien.

- Som nævnt ovenfor, er denne `memcpy` et stor grim fejl ... `rawData()` returnerer bytefeltet som er billedpunktets nuværende tilstand og `oldRawData()` returnerer bytefeltet som det var inden vi oprettete iteratoren. Vi kan imidlertid kopiere et forkert billedpunkt her. I praksis sker dette ikke alt for ofte, hvis ikke `dst` allerede findes og ikke er justeret i forhold til `src`.

- Men dette er rigtigt: I stedet for at regne ud hvilken byte som repræsenterer hvilken kanal, bruger vi en funktion som der sørges for af alle farverum til at invertere det nuværende billedpunkt. Farverum har en mængde billedpunktsoperationer som du kan udnytte.

Dette er ikke alt som behøves for at oprette et filter. Filtre har to andre vigtige komponenter: et indstillingsobjekt og en grafisk indstillingskontrol. De to fungerer tæt sammen. Den grafiske indstillingskomponenten laver et indstillingsobjekt, men kan også udfyldes fra et indstillingsobjekt som allerede eksisterer. Indstillingsobjekter kan repræsenteres som XML, og kan skabes fra XML. Det er det som gør justeringslag mulige.

### Iteratorer

Der er tre typer af iteratorer:

- Vandrette linjer

- Lodrette linjer

- Rektangulære iteratorer

De vandrette og lodrette linjeiteratorer har en metode til at flytte iteratoren til næste linje eller søjle: `nextRow()` og `nextCol()`. At bruge dem er meget hurtigere end at oprette en ny iterator for hver linje eller søjle.

Iteratorer er trådsikre i &krita;, så det er muligt at opdele arbejdet i flere tråde. Dog kommer fremtidige versioner af &krita; til at bruge metoden `supportsThreading()` til at afgøre om filtret kan bruges på stumper af billedet (dvs. alle billedpunkter ændrede uafhængig af hinanden, i stedet for ændrede af en værdi som bestemmes af at undersøge alle billedpunkter i billedet) og automatisk bruge tråde til at køre dit filter.

### `KisFilterConfiguration`

`KisFilterConfiguration` er en struktur som bruges til at gemme filterindstillinger på disken, for eksempel for justeringslag. Scriptpluginnet bruger egenskabsafbildningen som findes længst tilbage i `KisFilterConfigaration` for at gøre det muligt at lave scripter med filtre. Filtre kan sørge for en egen grafisk kontrol som &krita; viser i filtergalleriet, forhåndsvisningen af filtre og fanebladet med værktøjstilvalg for værktøjet Mal med filtre.

Et eksempel, som kommer fra filtret for oliemalerieffekt:

    class KisOilPaintFilterConfiguration : public KisFilterConfiguration
    {

    public:

       KisOilPaintFilterConfiguration(Q_UINT32 brushSize, Q_UINT32 smooth)
           : KisFilterConfiguration( "oilpaint", 1 )
           {
               setProperty("brushSize", brushSize);
               setProperty("smooth", smooth);
           };
    public:

       inline Q_UINT32 brushSize() { return getInt("brushSize"); };
       inline Q_UINT32 smooth() {return getInt("smooth"); };

    };

### `KisFilterConfigurationWidget`

De fleste filtre kan justeres af brugeren. Du kan oprette en indstillingskontrol som Krita bruger så snart filtret bruges. Et eksempel:

Dialogen Oliemaleri Dialogen Oliemaleri

Dialogen Oliemaleri

Bemærk at kun venstresiden af dialogen er dit ansvar: &krita; sørger for resten. Der er tre måder at opføre sig på for at oprette en tilvalgskontrol:

- Brug &Qt; Designer til at oprette basen for den grafiske kontrol, og opret en delklasse for dit filter

- Brug en af de simple grafiske kontroller som viser et antal skydere for lister af heltal, decimaltal med dobbelt præcision eller Booleske værdier. Se dokumentationen af programmeringsgrænsefladen for `KisMultiIntegerFilterWidget`, `KisMultiDoubleFilterWidget` og `KisMultiBoolFilterWidget`.

- Håndkod en grafisk kontrol. Dette anbefales ikke, og hvis du gør det og ønsker at filtret skal være en del af &krita;s officielle udgave, vil jeg bede dig om at erstatte din håndkodede kontrol med en &Qt; Designer-kontrol.

Oliemalerifiltret bruger multiheltalskontrollen:

    KisFilterConfigWidget * KisOilPaintFilter::createConfigurationWidget(QWidget* parent, KisPaintDeviceSP /*dev*/)
    {
       vKisIntegerWidgetParam param;
       param.push_back( KisIntegerWidgetParam( 1, 5, 1, i18n("Brush size"), "brushSize" ) );
       param.push_back( KisIntegerWidgetParam( 10, 255, 30, i18n("Smooth"), "smooth" ) );
       return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
    }

    KisFilterConfiguration* KisOilPaintFilter::configuration(QWidget* nwidget)
    {
       KisMultiIntegerFilterWidget* widget = (KisMultiIntegerFilterWidget*) nwidget;
       if( widget == 0 )
       {
           return new KisOilPaintFilterConfiguration( 1, 30);
       } else {
           return new KisOilPaintFilterConfiguration( widget->valueAt( 0 ), widget->valueAt( 1 ) );
       }
    }

    std::list<KisFilterConfiguration*> KisOilPaintFilter::listOfExamplesConfiguration(KisPaintDeviceSP )
    {
       std::list<KisFilterConfiguration*> list;
       list.insert(list.begin(), new KisOilPaintFilterConfiguration( 1, 30));
       return list;
    }

Du ser hvordan det virker: udfyld en vektor med heltalsparametre og opret den grafiske kontrol. Metoden `configuration()` inspicerer den grafiske kontrol og laver det rette filterindstillingsobjekt, i dette tilfælde naturligvis `KisOilPaintFilterConfiguration`. Metoden `listOfExamplesConfiguration` (som burde omdøbes til rigtigt engelsk ...) returnerer en liste med eksempelindstillingsobjekter for dialogen for filtergalleriet.

### Afslutning af filtre

Der kræves naturligvis mere for at kode interessante filtre, men med denne forklaring, dokumentationen af programmeringsgrænsefladen og adgang til vor kildekode, bør du kunne komme i gang. Tøv ikke med at kontakte udviklerne af &krita; på IRC eller via e-mail-listen.

## Værktøjer

Værktøjer vises i &krita;s værktøjskasse. Det betyder at der er begrænset plads til nye værktøjer: tænk nøje over om en maleoperation ikke er tilstrækkeligt til dit formål. Værktøjer kan bruge musen eller styrepladen og tastaturet på komplekse måder, hvilket maleoperationer ikke kan. Dette er grunden til at Duplikere er et værktøj, mens retuschsprøjte er en maleoperation.

Vær forsigtig med statisk data i værktøjet: en ny instans af værktøjet oprettes for hver inddataenhed: mus, pen, viskelæder, retuschsprøjte med mere. Værktøjer er opdelt i logiske grupper:

- formgivende maleværktøjer (cirkel, rektangel)

- frihåndsmaleværktøjer (pensel)

- transformeringsværktøj som ændrer et lags geometri

- udfyldningsværktøjer (såsom udfyldning eller toning)

- visningsværktøjer (som ikke ændrer billedpunkter, men ændrer måden du ser kanvassen, såsom zooming)

- markeringsværktøjer (som ændrer markeringsmasken)

Værktøjsgrænsefladen beskrives i dokumentationen af programmeringsgrænsefladen for `KisTool`. Der er tre delklasser: `KisToolPaint`, `KisToolNonPaint` og `KisToolShape` (som egentlig er en delklasse af `KisToolPaint`) som specialiserer `KisTool` for maleopgaver (dvs. ændre billedpunkter), ikke-maleopgaver og maleopgaver for former.

Et værktøj har en grafisk indstillingskontrol, præcis som filtre. For øjeblikket vises de grafiske indstillingskontroller i et faneblad i et dokket vindue. Det kan komme til at blive ændret til en linje under hovedmenuen (som så erstatter værktøjslinjen) for &krita; 2.0, men for øjeblikket skal indstillingskontroller konstrueres for at få plads i et faneblad. Som altid er det bedst at bruge &Qt; Designer til konstruktion af indstillingskontrollen.

Et godt eksempel på et værktøj er stjerneværktøjet:

    kis_tool_star.cc       Makefile.am   tool_star_cursor.png  wdg_tool_star.ui
    kis_tool_star.h        Makefile.in   tool_star.h
    kritatoolstar.desktop  tool_star.cc  tool_star.png

Som du ser, har du brug for to billeder: et for markøren og et for værktøjskassen. `tool_star.cc` indlæser kun pluginnet, på lignende måde som vi har set ovenfor. Det egentligt nyttige findes i implementeringen:

    KisToolStar::KisToolStar()
       : KisToolShape(i18n("Star")),
         m_dragging (false),
         m_currentImage (0)
    {
       setName("tool_star");
       setCursor(KisCursor::load("tool_star_cursor.png", 6, 6));
       m_innerOuterRatio=40;
       m_vertices=5;
    }

Konstruktoren laver det interne navn, som ikke oversættes, og kaldet til superklassen angiver det synlige navn. Vi indlæser også markørbilledet og tildeler værdier til et antal variabler.

    void KisToolStar::update (KisCanvasSubject *subject)
    {
       KisToolShape::update (subject);
       if (m_subject)
           m_currentImage = m_subject->currentImg();
    }

Metoden `update()` kaldes når værktøjet vælges. Dette er ikke en metode i `KisTool`, men en metode i `KisCanvasObserver`. Kanvasobservatører underrettes så snart noget ændres i visningen, hvilket kan være nyttigt for værktøjer.

Følgende metoder (`buttonPress`, `move` og `buttonRelease`) kaldes af &krita; når indtastningsenheden (mus, pen, viskelæder, osv.) trykkes ned, flyttes eller slippes. Bemærk at forflytningsbegivenheder også afgives hvis museknappen ikke er trykket ned. Begivenhederne er ikke de sædvanlige &Qt;-begivenheder, men syntetiske begivenheder i &krita;, eftersom vi drager nytte af trick på lavt niveau for at få tilstrækkeligt med begivenheder til at tegne en glat linje. Normalt smider værktøjskasser såsom &Qt; (og GTK) begivenheder væk hvis de er for travle til at håndtere dem, og vi vil have dem alle.

    void KisToolStar::buttonPress(KisButtonPressEvent *event)
    {
       if (m_currentImage && event->button() == LeftButton) {
           m_dragging = true;
           m_dragStart = event->pos();
           m_dragEnd = event->pos();
           m_vertices = m_optWidget->verticesSpinBox->value();
           m_innerOuterRatio = m_optWidget->ratioSpinBox->value();
       }
    }

    void KisToolStar::move(KisMoveEvent *event)
    {
       if (m_dragging) {
           // erase old lines on canvas
           draw(m_dragStart, m_dragEnd);
           // move (alt) or resize star
           if (event->state() & Qt::AltButton) {
               KisPoint trans = event->pos() - m_dragEnd;
               m_dragStart += trans;
               m_dragEnd += trans;
           } else {
               m_dragEnd = event->pos();
           }
           // draw new lines on canvas
           draw(m_dragStart, m_dragEnd);
       }
    }

    void KisToolStar::buttonRelease(KisButtonReleaseEvent *event)
    {
       if (!m_subject || !m_currentImage)
           return;

       if (m_dragging && event->button() == LeftButton) {
           // erase old lines on canvas
           draw(m_dragStart, m_dragEnd);
           m_dragging = false;

           if (m_dragStart == m_dragEnd)
               return;

           if (!m_currentImage)
               return;

           if (!m_currentImage->activeDevice())
               return;

           KisPaintDeviceSP device = m_currentImage->activeDevice ();;
           KisPainter painter (device);
           if (m_currentImage->undo()) painter.beginTransaction (i18n("Star"));

           painter.setPaintColor(m_subject->fgColor());
           painter.setBackgroundColor(m_subject->bgColor());
           painter.setFillStyle(fillStyle());
           painter.setBrush(m_subject->currentBrush());
           painter.setPattern(m_subject->currentPattern());
           painter.setOpacity(m_opacity);
           painter.setCompositeOp(m_compositeOp);
           KisPaintOp * op =
               KisPaintOpRegistry::instance()->paintOp(m_subject->currentPaintop(), m_subject->currentPaintopSettings(), &painter);
           painter.setPaintOp(op); // Painter takes ownership

           vKisPoint coord = starCoordinates(m_vertices, m_dragStart.x(), m_dragStart.y(), m_dragEnd.x(), m_dragEnd.y());

           painter.paintPolygon(coord);

           device->setDirty( painter.dirtyRect() );
           notifyModified();

           if (m_currentImage->undo()) {
               m_currentImage->undoAdapter()->addCommand(painter.endTransaction());
           }
       }
    }

Metoden `draw()` er en intern metode i `KisToolStar` som tegner stjernens omrids. Vi kalder den fra metoden `move()` for at give brugeren tilbagemelding om stjernens størrelse og form. Bemærk at vi bruger `Qt::NotROP` rasteroperationen, hvilket betyder at kalde `draw()` endnu en gang med samme start- og slutpunkt gør at stjernen fjernes.

    void KisToolStar::draw(const KisPoint& start, const KisPoint& end )
    {
       if (!m_subject || !m_currentImage)
           return;

       KisCanvasController *controller = m_subject->canvasController();
       KisCanvas *canvas = controller->kiscanvas();
       KisCanvasPainter p (canvas);
       QPen pen(Qt::SolidLine);

       KisPoint startPos;
       KisPoint endPos;
       startPos = controller->windowToView(start);
       endPos = controller->windowToView(end);

       p.setRasterOp(Qt::NotROP);

       vKisPoint points = starCoordinates(m_vertices, startPos.x(), startPos.y(), endPos.x(), endPos.y());

       for (uint i = 0; i < points.count() - 1; i++) {
           p.drawLine(points[i].floorQPoint(), points[i + 1].floorQPoint());
       }
       p.drawLine(points[points.count() - 1].floorQPoint(), points[0].floorQPoint());

       p.end ();
    }

Metoden `setup()` er fundamental: Her laver vi handlingen som vil blive puttet ind i værktøjskassen så brugere virkelig kan vælge værktøjet. Vi tildeler også en genvejstast. Bemærk at en del programkneb bruges her. Husk at vi oprettede en instans af værktøjet for hver indtastningsenhed. Det betyder også at vi kalder `setup()` for hver indtastningsenhed og at en handling med samme navn lægges til flere gange i handlingssamlingen. Men alt synes at virke, så hvorfor bekymre sig?

    void KisToolStar::setup(KActionCollection *collection)
    {
       m_action = static_cast<KRadioAction *>(collection->action(name()));

       if (m_action == 0) {
           KShortcut shortcut(Qt::Key_Plus);
           shortcut.append(KShortcut(Qt::Key_F9));
           m_action = new KRadioAction(i18n("&Star"),
                                       "tool_star",
                                       shortcut,
                                       this,
                                       SLOT(activate()),
                                       collection,
                                       name());
           Q_CHECK_PTR(m_action);

           m_action->setToolTip(i18n("Draw a star"));
           m_action->setExclusiveGroup("tools");
           m_ownAction = true;
       }
    }

Metoden `starCoordinates()` indeholder en del underlig matematik, men den er ikke særlig interessant i beskrivelsen af hvordan man laver værktøjsplugin.

    KisPoint KisToolStar::starCoordinates(int N, double mx, double my, double x, double y)
    {
       double R=0, r=0;
       Q_INT32 n=0;
       double angle;

       vKisPoint starCoordinatesArray(2*N);

       // the radius of the outer edges
       R=sqrt((x-mx)*(x-mx)+(y-my)*(y-my));

       // the radius of the inner edges
       r=R*m_innerOuterRatio/100.0;

       // the angle
       angle=-atan2((x-mx),(y-my));

       //set outer edges
       for(n=0;n<N;n++){
           starCoordinatesArray[2*n] = KisPoint(mx+R*cos(n * 2.0 * M_PI / N + angle),my+R*sin(n *2.0 * M_PI / N+angle));
       }

       //set inner edges
       for(n=0;n<N;n++){
           starCoordinatesArray[2*n+1] = KisPoint(mx+r*cos((n + 0.5) * 2.0 * M_PI / N + angle),my+r*sin((n +0.5) * 2.0 * M_PI / N + angle));
       }

       return starCoordinatesArray;
    }

Metoden `createOptionWidget()` kaldes for at oprette den grafiske indstillingskontrol som &krita; viser fanebladet. Eftersom der er et værktøj per indtastningsenhed og per visning, kan tilstanden af et værktøj opbevares i værktøjet. Denne metode kaldes kun en gang: den grafiske indstillingskontrol opbevares og hentes næste gang værktøjet aktiveres.

    QWidget* KisToolStar::createOptionWidget(QWidget* parent)
    {
       QWidget *widget = KisToolShape::createOptionWidget(parent);

       m_optWidget = new WdgToolStar(widget);
       Q_CHECK_PTR(m_optWidget);

       m_optWidget->ratioSpinBox->setValue(m_innerOuterRatio);

       QGridLayout *optionLayout = new QGridLayout(widget, 1, 1);
       super::addOptionWidgetLayout(optionLayout);

       optionLayout->addWidget(m_optWidget, 0, 0);

       return widget;
    }

### Afslutning af værktøj

Værktøjer er relativt simple plugin at oprette. Du skal kombinere grænsefladen `KisTool` og `KisCanvasObserver` for at oprette et værktøj effektivt.

## Maleoperationer

Maleoperationer er en af de mest opfindsomme typer af plugin i Krita (sammen med farverum som kan bruges som plugin). En maleoperation definerer hvordan værktøj ændrer de billedpunkter de berører. Retuschsprøjte, pen uden antialias eller billedpunktpensel med antialias er alle maleoperationer. Men du skulle kunne, med en stor mængde arbejde, oprette en maleoperation som læser Corel Paint XML-penseldefinitioner og bruger dem til at bestemme hvordan man skal male

Maleoperationer instantieres når et maleværktøj modtager begivenheden `mouseDown` og fjernes når begivenheden mouseUp modtages af et maleværktøj. I mellemtiden kan maleoperationen holde styr på tidligere positioner og anden information, såsom trykniveauer hvis brugeren bruger en styreplade.

Den grundlæggende handling for en maleoperation er at ændre billedpunkter ved et maleværktøjs markørposition. Det kan kun gøres en gang, eller også kan maleoperationen bede om at blive udført med regelmæssige intervaller, ved brug af en tidsmåler. Det første tilfælde er nyttigt for en penlignende maleoperation, og det andet naturligvis for en maleoperation som ligner en retuschsprøjte.

Maleoperationer kan have en lille grafisk indstillingskontrol som placeres i en værktøjslinje. Altså skal grafiske indstillingskontroller for maleoperationer have en vandret layout som ikke er højere end en knap i en værktøjslinje, ellers ville &krita; se meget mærkeligt ud.

Lad os kigge på et enkelt plugin for en maleoperation,, et som viser en vis mængde programbaseret intelligens. For det første er der en fabrik defineret i deklarationsfilen. Denne fabrik laver en maleoperation når det aktive værktøj behøver en:

    public:
       KisSmearyOpFactory() {}
       virtual ~KisSmearyOpFactory() {}

       virtual KisPaintOp * createOp(const KisPaintOpSettings *settings, KisPainter * painter);
       virtual KisID id() { return KisID("paintSmeary", i18n("Smeary Brush")); }
       virtual bool userVisible(KisColorSpace * ) { return false; }
       virtual QString pixmap() { return ""; }

    };

Fabrikken indeholder også `KisID` med det offentlige og private navn på maleoperationen, og kan valgfrtt returnere en punktafbildning. &krita; kan derefter vise punktafbildningen sammen med navnet som en visuel identifikation af maleoperationen. For eksempel vil maleoperationen malerkniv have et billede af et sådant værktøj. Sørg for at maleoperationens private navn ikke kommer i konflikt med en anden maleoperation.

Implementeringen af maleoperationer er meget ligetil:

    KisSmearyOp::KisSmearyOp(KisPainter * painter)
       : KisPaintOp(painter)
    {
    }

    KisSmearyOp::~KisSmearyOp()
    {
    }
    void KisSmearyOp::paintAt(const KisPoint &pos, const KisPaintInformation& info)
    {

Metoden `paintAt()` er stedet hvor alt sker for maleoperationer. Denne metode har to parametre, den nuværende position (som angives i floats, ikke i hele billedpunkter) og objektet `KisPaintInformation`, som indeholder tryk, x, y, hældning og forflytningsvektor, og som kan udvides med yderligere information i fremtiden.

    if (!m_painter->device()) return;

       KisBrush *brush = m_painter->brush();

En `KisBrush` er repræsentationen af en Gimp penselfil: det vil sige en maske, enten en enkelt maske eller en serie masker. I virkeligheden bruger vi ikke penslen her, men til at bestemme malepunktet under markøren.

    Q_ASSERT(brush);

       if (!brush) return;

       if (! brush->canPaintFor(info) )
           return;

       KisPaintDeviceSP device = m_painter->device();
       KisColorSpace * colorSpace = device->colorSpace();
       KisColor kc = m_painter->paintColor();
       kc.convertTo(colorSpace);

       KisPoint hotSpot = brush->hotSpot(info);
       KisPoint pt = pos - hotSpot;

       // Split the coordinates into integer plus fractional parts. The integer
       // is where the dab will be positioned and the fractional part determines
       // the sub-pixel positioning.
       Q_INT32 x, y;
       double xFraction, yFraction;

       splitCoordinate(pt.x(), &x, &xFraction);
       splitCoordinate(pt.y(), &y, &yFraction);

       KisPaintDeviceSP dab = new KisPaintDevice(colorSpace, "smeary dab");
       Q_CHECK_PTR(dab);

Vi ændrer ikke billedpunkterne på en maleenheden direkte: i stedet laver vi en lille maleenhed, en dab, og sammensætter den med den nuværende maleenhed.

    m_painter->setPressure(info.pressure);

I overensstemmelse med kommentarerne, udfører følgende kodestump lidt programarbejde for at oprette selve dabben. I dette tilfælde tegner vi et antal linjer. Når maleoperationen er færdig, kommer linjernes længde, position og tykhed til at afhænge af tryk og farvemængde, og vi har oprettet en stiv, smidig oljefarvepensel. Men jeg har ikke haft tid at afslutte dette endnu.

    // Compute the position of the tufts. The tufts are arranged in a line
       // perpendicular to the motion of the brush, i.e, the straight line between
       // the current position and the previous position.
       // The tufts are spread out through the pressure

       KisPoint previousPoint = info.movement.toKisPoint();
       KisVector2D brushVector(-previousPoint.y(), previousPoint.x());
       KisVector2D currentPointVector = KisVector2D(pos);
       brushVector.normalize();

       KisVector2D vl, vr;

       for (int i = 0; i < (NUMBER_OF_TUFTS / 2); ++i) {
           // Compute the positions on the new vector.
           vl = currentPointVector + i * brushVector;
           KisPoint pl = vl.toKisPoint();
           dab->setPixel(pl.roundX(), pl.roundY(), kc);

           vr = currentPointVector - i * brushVector;
           KisPoint pr = vr.toKisPoint();
           dab->setPixel(pr.roundX(), pr.roundY(), kc);
       }

       vr = vr - vl;
       vr.normalize();

Tilsidst overfører vi dabben med en blokoverførsel på den oprindelige maleenhed og fortæller maleren at vi har påvirket et lille rektangel på maleenheden.

    if (m_source->hasSelection()) {
           m_painter->bltSelection(x - 32, y - 32, m_painter->compositeOp(), dab.data(),
                                   m_source->selection(), m_painter->opacity(), x - 32, y -32, 64, 64);
       }
       else {
           m_painter->bitBlt(x - 32, y - 32, m_painter->compositeOp(), dab.data(), m_painter->opacity(), x - 32, y -32, 64, 64);
       }

       m_painter->addDirtyRect(QRect(x -32, y -32, 64, 64));
    }

    KisPaintOp * KisSmearyOpFactory::createOp(const KisPaintOpSettings */*settings*/, KisPainter * painter)
    {
       KisPaintOp * op = new KisSmearyOp(painter);
       Q_CHECK_PTR(op);
       return op;
    }

Det er alt: maleoperationer er nemme og sjove!

## Visningsplugin

Visningsplugin er de mærkeligste i hele gænget: Et visningsplugin er en sædvanlig KPart som kan sørge for en vss mængde brugergrænseflade og en del funktioner. Histogramfanebladet er for eksempel et visningsplugin, ligesom rotationsdialogen.

## Import- og eksportfiltre

&krita; arbejder med den sædvanlige filterarkitektur for filer i &koffice;. Der findes en vejledning, noget gammel, men stadigvæk nyttig, på: . Det er sandsynligvis bedst at samarbejde med &krita;-gruppen ved udvikling af filfiltere og at gøre udviklingen i &koffice; filtertræ. Bemærk at du kan teste filtre uden at køre &krita; ved at bruge værktøjet `koconverter`.

Filtre har to sider: import og eksport. De er oftest to forskellige plugin som kan dele noget kode.

De vigtige indgange i `Makefile.am` er:

    service_DATA = krita_XXX_import.desktop krita_XXX_export.desktop
    servicedir = $(kde_servicesdir)
    kdelnk_DATA = krita_XXX.desktop
    kdelnkdir = $(kde_appsdir)/Office
    libkritaXXXimport_la_SOURCES = XXXimport.cpp
    libkritaXXXexport_la_SOURCES = XXXexport.cpp
    METASOURCES = AUTO

Uafhængigt af om du laver et importfilter eller et eksportfilter, er indholdet af arbejdet altid at implementere følgende funktion:

    virtual KoFilter::ConversionStatus convert(const QCString& from, const QCString& to);

Det er indstillingerna i filen `.desktop` som afgør på hvilken måde et filter konverterer:

Import:

    X-KDE-Export=application/x-krita
    X-KDE-Import=image/x-xcf-gimp
    X-KDE-Weight=1
    X-KDE-Library=libkritaXXXimport
    ServiceTypes=KOfficeFilter

Eksport:

    X-KDE-Export=image/x-xcf-gimp
    X-KDE-Import=application/x-krita
    ServiceTypes=KOfficeFilter
    Type=Service
    X-KDE-Weight=1
    X-KDE-Library=libkritaXXXexport

Og ja, MIME-typen som er valgt i eksemplet er en antydning: Vær virkelig sød og implemetér et XCF-filter!

### Import

Det store problem med importfiltre er naturligvis koden til at læse data på disken. Standardkoden for at kalde denne kode er ganske enkel:

Bemærk: Vi burde virkelig finde en måde at gøre det muligt for &krita; at holde en fil åben kun læse data efterhånden som det behøves, i stedet for at kopiere hele indholdet til den interne repræsentationen i maleenheden. Men det ville betyde en grænseflade for datahåndtering som kender til TIFF-filer og så videre, og dette er for øjeblikket ikke implementeret. Det ville være ideelt hvis visse filfiltre kunne implementere en klasse, preliminært kaldet `KisFileDataManager`, oprette et objekt af den instans med den nuværende fil og sende den til KisDoc. Men &krita; håndterer opbevaring per lag, ikke per dokument, så det ville være en svær omskrivning.

    KoFilter::ConversionStatus XXXImport::convert(const QCString&, const QCString& to)
    {
       if (to != "application/x-krita")
           return KoFilter::BadMimeType;

       KisDoc * doc = dynamic_cast<KisDoc*>(m_chain -> outputDocument());
       KisView * view = static_cast<KisView*>(doc -> views().getFirst());

       QString filename = m_chain -> inputFile();

       if (!doc)
           return KoFilter::CreationError;

       doc -> prepareForImport();

       if (!filename.isEmpty()) {

           KURL url(filename);

           if (url.isEmpty())
               return KoFilter::FileNotFound;

           KisImageXXXConverter ib(doc, doc -> undoAdapter());

           if (view != 0)
               view -> canvasSubject() ->  progressDisplay() -> setSubject(&ib, false, true);

           switch (ib.buildImage(url))  {
               case KisImageBuilder_RESULT_UNSUPPORTED:
                   return KoFilter::NotImplemented;
                   break;
               case KisImageBuilder_RESULT_INVALID_ARG:
                   return KoFilter::BadMimeType;
                   break;
               case KisImageBuilder_RESULT_NO_URI:
               case KisImageBuilder_RESULT_NOT_LOCAL:
                   return KoFilter::FileNotFound;
                   break;
               case KisImageBuilder_RESULT_BAD_FETCH:
               case KisImageBuilder_RESULT_EMPTY:
                   return KoFilter::ParsingError;
                   break;
               case KisImageBuilder_RESULT_FAILURE:
                   return KoFilter::InternalError;
                   break;
               case KisImageBuilder_RESULT_OK:
                   doc -> setCurrentImage( ib.image());
                   return KoFilter::OK;
               default:
                   break;
           }

       }
       return KoFilter::StorageCreationError;
    }

- Dette er beregnet til at være et importfilter, så hvis det ikke kaldes for at konvertere til et billede i &krita;, er der noget som er forkert.

- Filterkæden har allerede oprettet et uddatadokument for os. Vi skal typekonvertere det til `KisDocM`, eftersom &krita;-dokumenter kræver særlig behandling. Det ville i virkeligheden ikke være en dum idé at kontrollere at resultatet af typekonverteringen ikke er 0, eftersom hvis den er det vil importen mislykkes.

- Hvis vi kalder filtret fra den grafiske grænseflade, forsøger vi at få visningen. Hvis der er en visning, kan konverteringskoden forsøge at opdatere fremgangslinjen.

- Filtret har filnavnet på inddatafilen for os.

- `KisDoc` skal forberedes for import. Visse indstillinger initieres og fortryd deaktiveres. Ellers ville du kunne fortryde tilføjelse af lag som udføres af importfiltret, og det er en mærkelig opførsel.

- Jeg har valgt at implementere selve importkoden i en separat klasse som jeg instantierer her. Du kan også lægge al din kode direkte i denne metode, men det ville være lidt rodet.

- Min importkode returnerer en statuskode, som jeg siden kan bruge til at angive status for importfiltret. &koffice; sørger for at vise fejlmeddelelser.

- Hvis det er lykkedes at oprette `KisImage` sætter vi dokumentets nuværende billede til vort nyoprettede billede. Derefter er vi færdige: `return KoFilter::OK;`.