# Utveckla insticksprogram för &chalk;

## ↓Inledning

&chalk; kan utökas i det oändliga med insticksprogram. Verktyg, filter, stora delar av användargränssnittet och alla färgrymder är insticksprogram. I själva verket känner &chalk; igen följande sex typer av insticksprogram:

- färgrymder — de definierar kanalerna som utgör en enstaka bildpunkt

- verktyg — allt som utförs med en mus eller styrplatta

- ritoperationer — riteffekter för verktyg som kan laddas

- bildfilter — ändra alla bildpunkter, eller bara markerade bildpunkter i ett lager

- vyinsticksprogram — utökar Chalks användargränssnitt med nya dialogrutor, paletter och åtgärder

- import- och exportfilter — läs och skriv alla sorters bildformat

Själva &chalk; består av tre bibliotek i lager och en katalog med vissa gemensamma stödklasser: chalkcolor, chalkimage och chalkui. Inne i &chalk; kan objekt identifieras av ett `KisID`, som är kombinationen av en unik oöversatt sträng (som till exempel används när något ska sparas) och en översatt sträng avsedd för det grafiska användargränssnittet.

Ett ord om kompatibilitet: &chalk; är fortfarande under utveckling. Om du utvecklar ett insticksprogram för &chalk; och väljer att göra det i &chalk;s subversion-arkiv, finns det utmärkta möjligheter att vi hjälper dig med överföringen. Ändringarna kan också göra att vissa delar av det här dokumentet blir föråldrade. Kontrollera alltid den senaste dokumentationen av programmeringsgränssnittet eller deklarationsfilerna som är installerade på ditt system.

### ChalkColor

Det första biblioteket är chalkcolor. Detta bibliotek laddar färgrymdsinsticksprogram.

Ett färgrymdsinsticksprogram ska implementera den abstrakta klassen `KisColorSpace`, eller om de grundläggande funktionerna i den nya färgrymden kommer att implementeras av `lcms` (), utöka `KisAbstractColorSpace`. Biblioteket chalkcolor kan användas från andra program, och beror inte på &koffice;.

### ChalkImage

Biblioteket libchalkimage laddar filter- och ritoperationsinsticksprogram, och är ansvarigt för att arbeta med bilddata: ändra bildpunkter, sammanfoga och måla. Penslar, paletter, toningar och mönster laddas också av libchalkimage. Det är ett uttalat mål att göra libchalkimage oberoende av &koffice;, men för närvarande delar vi koden för att ladda toningar med &koffice;.

Det är för närvarande inte enkelt att lägga till nya typer av resurser såsom penslar, paletter, toningar eller mönster i &chalk;. (Att lägga till nya penslar, paletter, toningar och mönster är förstås enkelt.) &chalk; följer anvisningarna från projektet Create () för dessa. Att lägga till stöd för Photoshops penselfilformat kräver kodning i libchalkimage. Att lägga till fler penseldatafiler från Gimp kräver inte det.

`ChalkImage` laddar följande insticksprogramtyper:

- Filter i &chalk; måste utöka och implementera den abstrakta klassen `KisFilter`, `KisFilterConfiguration` och möjligen `KisFilterConfigurationWidget`. Ett exempel på ett filter är Oskarp mask.

- Ritoperationer är den uppsättning av operationer som ritverktyg som frihand eller cirkel har tillgång till. Exempel på ritoperationer är penna, retuschspruta eller radergummi. Ritoperationer ska utöka basklassen `KisPaintop`. Exempel på nya ritoperationer skulle kunna vara en chalk, en pensel för oljemålning eller en komplex programmerbar pensel.

### ChalkUI

Biblioteket libchalkui laddar verktygen och vyinsticksprogrammen. Biblioteket är ett &koffice;-delprogram, men innehåller också ett antal grafiska komponenter som är användbara i grafikprogram. Kanske måste biblioteket delas i chalkpart och chalkui för utgåva 2.0. För närvarande ges inte författare av skript tillgång till biblioteket och författare av insticksprogram tillåts bara använda biblioteket när verktyg och vyinsticksprogram skrivs. `ChalkUI` laddar följande insticksprogramtyper:

- Verktyg härleds från `KisTool` eller en av de specialiserade verktygsbasklasserna såsom `KisToolPaint`, `KisToolNonPaint` eller `KisToolFreehand`. Ett nytt verktyg kan vara ett verktyg för markering av förgrunden. Ritverktyg (och det omfattar verktyg som ritar på markeringen) kan använda vilken ritoperation som helst för att bestämma hur bildpunkter ändras.

- Vyinsticksprogram är vanliga KParts, som använder `kxmlgui` för att ta sig in i &chalk;s användargränssnitt. Menyalternativ, dialogrutor, verktygsrader — alla sorters utökningar av användargränssnittet kan vara vyinsticksprogram. I själva verket är viktiga funktioner, som &chalk;s stöd för skript, skrivna som vyinsticksprogram.

### Import- och exportfilter

Import- och exportfilter är &koffice;-filter, delklasser till `KoFilter`. Filter läser och skriver bilddata på något av den uppsjö av bildformat som existerar. Ett exempel på ett nytt import- och exportfiler för &chalk; skulle kunna vara ett PDF-filter. Filter laddas av &koffice;-biblioteken.

## Skapa insticksprogram

Insticksprogram skrivs i C++ och kan använda hela programmeringsgränssnittet i &tde; och &TQt; samt &chalk;s utvecklingsgränssnitt. Bara vyinsticksprogram ska använda &koffice; programmeringsgränssnittet. Oroa dig inte, &chalk;s programmeringsgränssnitt är mycket rent och relativt utförligt dokumenterat (för att vara fri programvara) och att koda ditt första filter är mycket enkelt.

Om du inte vill använda C++ kan du skriva skript i Python eller Ruby: det är dock en helt annan sak, och du kan för närvarande inte skriva verktyg, färgrymder, ritoperationer eller import- och exportfilter som skript.

Insticksprogram i &chalk; använder &kde;:s mekanism för delprogram vid laddning, så dokumentationen om delprogram på är också relevant här.

Relevanta deklarationsfiler ska antingen ha installerats med själva &chalk; av din distribution, eller så har kanske deklarationsfilerna antingen lagts i paketet &koffice;-dev eller i &chalk;-dev. Du hittar dokumentationen av &chalk;s externa programmeringsgränssnitt på .

### Automake (och CMake)

&kde; 3.x och sålunda &koffice; 1.5 och 1.6 använder `automake`. &kde; 4.0 och &koffice; 2.0 använder `cmake`. Den här handledningen beskriver sättet att skapa insticksprogram som använder `automake`.

Insticksprogram är &kde;-moduler, och ska markeras som sådana i `Makefile.am`. Filter, verktyg, ritoperationer, färgrymder samt import- och exportfiler behöver `.desktop`-filer. Vyinsticksprogram behöver dessutom en KXMLGui `insticksprogramnamn.rc`-fil. Det enklaste sättet att komma igång är att checka ut projektet chalk-plugins från &koffice; Subversion-arkiv och använda det som bas för ditt eget projekt. Vi har för avsikt att skapa ett paket med en &chalk; insticksprogrammall för Kdevelop, men har inte fått tid att göra det ännu.

#### `Makefile.am`

Låt oss ta en titt på mallen för en insticksmodul. Först filen `Makefile.am`. Den är vad &kde; använder för att skapa byggfilen som bygger insticksporgrammet:

    kde_services_DATA = chalkBIBLIOTEKSNAMN.desktop

    INCLUDES = $(all_includes)

    chalkBIBLIOTEKSNAMN_la_SOURCES = sourcefile1.cpp sourcefile2.cpp

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

    chalkBIBLIOTEKSNAMN_la_LDFLAGS = $(all_libraries) -module $(KDE_PLUGIN)
    chalkLIBRARY_la_LIBADD = -lchalkcommon

    chalkextensioncolorsfilters_la_METASOURCES = AUTO

Detta är byggfilen för ett filterinsticksprogram. Ersätt `BIBLIOTEKSNAMN` med namnet på ditt arbete, så är du klar.

Om ditt insticksprogram är ett vyinsticksprogram, installerar du troligen också en `.rc`-fil med poster för menyrader och verktygsrader. På liknande sätt kanske du också behöver installera markörer och ikoner. Allt detta görs via de magiska besvärjelserna i &kde;:s vanliga `Makefile.am`.

    chalkrcdir = $(kde_datadir)/chalk/chalkplugins
    chalkrc_DATA = BIBLIOTEKSNAMN.rc
    EXTRA_DIST = $(chalkrc_DATA)

    chalkpics_DATA = \
       bla.png \
       bla_cursor.png
    chalkpicsdir = $(kde_datadir)/chalk/pics

#### Skrivbordsfiler

Filen `.desktop` talar om insticksprogrammets typ:

    [Desktop Entry]
    Encoding=UTF-8
    Icon=
    Name=User-visible Name
    ServiceTypes=Chalk/Filter
    Type=Service
    X-TDE-Library=chalkBIBLIOTEKSNAMN
    X-TDE-Version=2

Möjliga tjänsttyper är:

- Chalk/Filter

- Chalk/Paintop

- Chalk/ViewPlugin

- Chalk/Tool

- Chalk/ColorSpace

Import- och exportfiler för filer använder det generella filterramverket i &koffice; och behöver beskrivas separat.

#### Standardkod

Du behöver också en del standardkod som anropas av &kde;:s ramverk för delprogram för att instantiera insticksprogrammet — en deklarationsfil och en implementeringsfil.

En deklarationsfil:

    #ifndef TOOL_STAR_H_
    #define TOOL_STAR_H_

    #include <tdeparts/plugin.h>

    /**
    * En modul som tillhandahåller ett stjärnverktyg.
    */
    class ToolStar : public KParts::Plugin
    {
       TQ_OBJECT
    public:
       ToolStar(TQObject *parent, const char *name, const QStringList &);
       virtual ~ToolStar();

    };

    #endif // TOOL_STAR_H_

Och en implementeringsfil:

    #include <tdeinstance.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( chalktoolstar, ToolStarFactory( "chalk" ) )

    ToolStar::ToolStar(TQObject *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"

#### Registrering

Verktyg laddas av verktygsregistret och registrerar sig själva med verktygsregistret. Insticksprogram som verktyg, filter och ritoperationer laddas bara en gång. Vyinsticksprogram laddas för varje vy som skapas. Observera att i allmänhet registrerar vi fabriker. För verktyg skapas exempelvis en ny instans av ett verktyg för varje pekare (mus, penna, radergummi), och en ny ritoperation skapas så fort ett verktyg får händelsen musklick.

Filter anropar filterregistret:

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

Ritoperationer ritoperationsregistret:

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

Färgrymder färgrymdsregistret (med vissa 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) );
       }

vyinsticksprogram har inte något eget register, och de får tillgång till ett objekt av klassen `KisView`:

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

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

           m_view = (KisView*) parent;
       }

Kom ihåg att detta betyder att ett vyinsticksprogram skapas för varje vy som användaren skapar: att dela en vy betyder att alla vyinsticksprogram laddas igen.

#### Versionshantering av insticksprogram

&chalk; 1.5 laddar insticksprogram med `X-TDE-Version=2` angivet i `.desktop`-filen. &chalk; 1.6 kommer troligen inte vara binärt kompatibla med 1.5 insticksprogram och kommer att behöva versionsnumret 3. &chalk; 2.0 insticksprogram kommer att behöva versionsnumret 3. Ja, det är inte helt logiskt.

## Färgrymder

Färgrymder implementerar den rent virtuella klassen `KisColorSpace`. Det finns två typer av färgrymder: de som kan använda `lcms` för överföringar mellan färgrymder, och de som är för konstiga för `lcms` att hantera. Exempel på de första är cmyk, rgb, yuv. Ett exempel på den senare är watercolor eller wet & sticky. Färgrymder som använder `lcms` kan härledas från `KisAbstractColorSpace` eller en av basklasserna som är specialiserade för ett visst antal bitar per kanal.

Det är ganska enkelt att implementera en färgrymd. Den allmänna principen är att färgrymder arbetar med ett enkelt fält av byte. Tolkningen av dessa bestäms av färgrymden själv. Till exempel består en bildpunkt i 16-bitars GrayA av fyra byte: två för gråskalevärdet och två för alfavärdet. Du är fri att använda en post för att arbeta med minneslayouten av en bildpunkt i din implementering av färgrymden, men den representationen exporteras inte. Det enda sättet som resten av &chalk; kan veta vilka kanaler och typer av kanaler din färgrymds bildpunkter består av är via klassen `KisChannelInfo`.

Filter och ritoperationer utnyttjar den omfattande mängd metoder som tillhandahålls av `KisColorSpace` för att utföra sitt arbete. I många fall fungerar standardimplementeringen i `KisAbstractColorSpace` men långsammare än en egen implementering i din egen färgrymd, eftersom `KisAbstractColorSpace` konverterar alla bildpunkter till 16-bitars L*a*b och tillbaka.

### `KisChannelInfo`

    (http://websvn.kde.org/trunk/koffice/chalk/chalkcolor/kis_channelinfo.h)

Den här klassen definierar kanalerna som utgör en ensam bildpunkt i en viss färgrymd. En kanal har följande viktiga egenskaper:

- ett namn på en skärm i användargränssnittet

- en position: den byte där alla de byte som representerar kanalen börjar i bildpunkten.

- en typ: färg, alfa, substans eller substrat. Färg är vanlig färg, alfa är genomskinlighet, substans är en representation av mängden pigment eller likande saker, substrat är en representation av duken. (Observera att det kan ändras om snabbt som ögat.)

- en värdetyp: byte, short, integer, float — eller något annat.

- storlek: antal byte som kanalen upptar

- färg: en representation med `TQColor` av kanalen för visualisering i användargränssnitt, till exempel i histogram.

- en förkortning att använda i det grafiska användargränssnittet när det inte finns mycket utrymme

### `KisCompositeOp`

Liksom för den ursprungliga Porter-Duff, finns det många sätt att kombinera bildpunkter för att få en ny färg. Klassen `KisCompositeOp` definierar de flesta av dem: Uppsättningen kan inte enkelt utökas utom genom att ändra kod i biblioteket chalkcolor.

Ett färgrymdsinsticksprogram kan stödja vilken delmängd av de möjliga sammansättningsoperationerna som helst, men uppsättningen måste alltid omfatta "OVER" (samma som "NORMAL") och "COPY". De övriga är mer eller mindre valfria, även om fler naturligtvis är bättre.

### `KisColorSpace`

Metoderna i den rent virtuella klassen `KisColorSpace` kan delas upp i ett antal grupper: konvertering, identifikation och behandling.

Alla klasser måste kunna konvertera en bildpunkt från och till 8-bitars RGB (dvs. en `TQColor`), och helst också till och från 16-bitars L*a*b*. Dessutom finns en metod för att konvertera till vilken annan färgrymd som helst från den nuvarande färgrymden.

Färgrymder beskrivs av vektorn `KisChannelInfo`, antal kanaler, antal byte i en enda bildpunkt, om den stöder bilder med stort dynamiskt område, med mera.

Behandling är till exempel att kombinera två bildpunkter till en ny bildpunkt: bitBlt, att göra bildpunkter mörkare eller faltning av bildpunkter.

Titta i dokumentationen av programmeringsgränssnittet för en fullständig beskrivning av alla metoder du måste implementera i en färgrymd.

`KisAbstractColorSpace` implementerar många av de virtuella metoderna i `KisColorSpace` med användning av funktioner från biblioteket `lcms`. Ovanpå `KisAbstractColorSpace` finns det basklasser för färgrymder med 8- och 16-bitars heltal samt 16- och 32-bitars flyttal som definierar gemensamma operationer för att gå mellan bitdjup.

## Filter

Filter är insticksprogram som undersöker bildpunkter i ett lager och därefter utför ändringar av dem. Även om &chalk; använder ett effektiv minnesgränssnitt baserat på plattor för att lagra bildpunkter, behöver upphovsmän till filter inte bekymra sig om det. När ett filterinsticksprogram skrivs för bildbehandlingsgränssnittet i &Java;, Photoshop eller Gimp måste man ta hand om plattornas kanter och passa ihop plattor med varandra. &chalk; döljer alla sådana implementeringsdetaljer.

Observera att det teoretiskt är enkelt att ersätta det nuvarande gränssnittet för datalagring baserat på plattor med ett annat gränssnitt, men att gränssnitten av prestandaskäl för närvarande inte är riktiga insticksprogram.

&chalk; använder interation för att läsa och skriva bildpunktsvärden. Som ett alternativ kan du läsa in ett block med bildpunkter i en minnesbuffer, greja med det och därefter skriva tillbaka det som ett block. Det är dock inte nödvändigtvis effektivare, utan kan till och med vara långsammare än att använda iteration: det kanske bara är bekvämare. Se dokumentationen av programmeringsgränssnittet.

Bilder i &chalk; består av lager, varav det för närvarande finns fyra sorter: ritlager, grupplager, justeringslager (som innehåller ett filter som dynamiskt används för lager under justeringslagret) och delprogramlager. Filter arbetar alltid med ritlager. Ritlager innehåller uppritningsenheter av klassen `KisPaintDevice`. En uppritningsenhet ger i sin tur möjlihet att komma åt själva bildpunkterna.

En `PaintDevice` skickas i allmänhet omkring inbäddad i en delad pekare. En delat pekare håller ordning på hur många ställen som uppritningsenheten för närvarande används, och tar bort uppritningsenheten när den inte längre används någonstans. Du känner igen versionen av en uppritningsenhet med en delad pekare på dess suffix `SP`. Kom bara ihåg att du aldrig explicit behöver ta bort en `KisPaintDeviceSP`.

Låt oss undersöka ett mycket enkelt filter, ett som inverterar alla bildpunkter. Koden för filtret finns i katalogen `koffice/chalk/plugins/filters/example`. Huvudmetoden är:

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

Funktionen tar emot två uppritningsenheter, ett inställningsobjekt (som inte används i det här enkla filtret) och en `rect`. Denna `rect` beskriver uppritningsenhetens område som filtret ska hantera. Området beskrivs med heltal, vilket betyder att det inte finns någon noggrannhet på delbildpunktsnivå.

Uppritningsenheten `src` är till för att läsa från, och uppritningsenheten `dst` är till för att skriva till. Parametrarna kan peka på samma verkliga uppritningsenhet, eller vara två olika uppritningsenheter. (Observera: detta kan ändras till en enda uppritningsenhet i framtiden.)

Låt oss nu betrakta koden rad för rad:

    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(); // Måste anropas även om det inte stöds
    }

- Detta skapar en iteration för att läsa befintliga bildpunkter. Chalk har tre typer av iteration: horisontell, vertikal och rektangulär. Iterationen rect går det effektivaste vägen genom bilddata, men garanterar inte någonting om platsen för nästa bildpunkt den returnerar. Det betyder att du inte kan vara säker på att bildpunkten du hämtar nästa gång ligger intill bildpunkten du just tog emot. De horisontella och vertikala iterationerna garanterar verkligen platsen för bildpunkterna de returnerar.

- Vi skapar destinationsiterationen med värdet `true` för inställningen `write`. Det betyder att om destinationens uppritningsenhet är mindre än rektangeln vi skriver, förstoras den automatiskt för att omfatta alla bildpunkter i iterationen. Observera att vi har ett potentiellt fel här: om `dst` och `src` inte är samma enhet är det mycket möjligt att bildpunkterna som iterationerna returnerar inte motsvarar varandra. För varje position i iterationen kan `src` till exempel vara 165, 200, medan `dst` skulle kunna vara 20, 8 — och därför skulle kopian vi gör nedan kunna förvränga bilden ...

- Vill du veta om en bildpunkt är markerad? Det är enkelt: använd metoden `isSelected`. Men att vara markerad är inte en binär egenskap hos en bildpunkt. En bildpunkt kan vara halvmarkerad, nästan omarkerad, eller nästan helt markerad. Markeringar är i själva verket en maskuppritningsenhet med intervallet 0 till 255, där 0 är helt omarkerad och 255 helt markerad. Iterationen har två metoder: `isSelected()` and `selectedNess()`. Det första returnerar sant om en bildpunkt överhuvudtaget är markerad (dvs. maskvärdet är större än 1), den andra returnerar maskvärdet.

- Som nämndes ovan, är denna `memcpy` ett stort fult fel ... `rawData()` returnerar bytefältet som är bildpunktens nuvarande tillstånd och `oldRawData()` returnerar bytefältet som det var innan vi skapade iterationen. Vi kan dock kopiera fel bildpunkt här. I verklig användning händer inte det alltför ofta, om inte `dst` redan finns och inte är justerad i förhållande till `src`.

- Men det är riktigt: Istället för att räkna ut vilken byte som representerar vilken kanal, använder vi en funktion som tillhandahålls av alla färgrymder för att invertera den aktuella bildpunkten. Färgrymderna har en mängd bildpunktsoperationer som du kan utnyttja.

Detta är inte allt som behövs för att skapa ett filter. Filter har två andra viktiga komponenter: ett inställningsobjekt och en grafisk inställningskomponent. De två fungerar tätt tillsammans. Den grafiska inställningskomponenten skapar ett inställningsobjekt, men kan också fyllas i från ett inställningsobjekt som redan existerar. Inställningsobjekt kan representeras som XML, och kan skapas från XML. Det är det som gör justeringslager möjliga.

### Iterationer

Det finns tre typer av iterationer:

- Horisontella linjer

- Vertikala linjer

- Rektangulära iterationer

De horisontella och vertikala linjeiterationerna har en metod för att flytta iterationen till nästa rad eller kolumn: `nextRow()` och `nextCol()`. Att använda dem är mycket snabbare än att skapa en ny iteration för varje rad eller kolumn.

Iterationer är trådsäkra i &chalk;, så det är möjligt att dela upp arbetet i flera trådar. Dock kommer framtida versioner av &chalk; att använda metoden `supportsThreading()` för att avgöra om filtret kan användas på stycken av bilden (dvs. alla bildpunkter ändrade oberoende av varandra, istället för ändrade av något värde som bestäms av att undersöka alla bildpunkter i bilden) och automatiskt använda trådar för att köra filtret.

### `KisFilterConfiguration`

`KisFilterConfiguration` är en struktur som används för att spara filterinställningar på disk, till exempel för justeringslager. Skriptinsticksprogrammet använder egenskapsavbildningen som finns längst bak i `KisFilterConfigaration` för att göra det möjligt att göra skript med filter. Filter kan tillhandahålla en egen grafisk komponent som &chalk; visar i filtergalleriet, förhandsgranskningen av filter och fliken med verktygsalternativ för verktyget Rita med filter.

Ett exempel, som kommer från filtret för oljemålningseffekt:

    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 flesta filter kan justeras av användaren. Du kan skapa en inställningskomponent som Chalk användaer så fort filtret används. Ett exempel:

Dialogrutan Oljemålning Dialogrutan Oljemålning

Dialogrutan Oljemålning

Observera att bara vänstersidan av dialogrutan är ditt ansvar: &chalk; tar hand om resten. Det finns tre sätt att bete sig för att skapa en alternativkomponent:

- Använd &TQt; Designer för att skapa basen för den grafiska komponenten, och skapa en delklass för filtret

- Använd en av de enklaste grafiska komponenterna som visar ett antal skjutreglage för listor av heltal, flyttal med dubbel precision eller Booleska värden. Se dokumentationen av programmeringsgränssnittet för `KisMultiIntegerFilterWidget`, `KisMultiDoubleFilterWidget` och `KisMultiBoolFilterWidget`.

- Handkoda en grafisk komponent. Det rekommenderas inte, och om du gör det och vill att filtret ska vara en del av &chalk;s officiella utgåva, ber jag dig att ersätta din handkodade komponent med en &TQt; Designer-komponent.

Oljemålningsfiltret använder flerheltalskomponenten:

    KisFilterConfigWidget * KisOilPaintFilter::createConfigurationWidget(TQWidget* 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(TQWidget* 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 hur det fungerar: Fyll i en vektor med heltalsparametrar och skapa den grafiska komponenten. Metoden `configuration()` inspekterar den grafiska komponenten och skapar det rätta filterinställningsobjektet, i detta fall förstås `KisOilPaintFilterConfiguration`. Metoden `listOfExamplesConfiguration` (som borde döpas om till riktig engelska ...) returnerar en lista med exempelinställningsobjekt för dialogrutan med filtergalleriet.

### Avslutning av filter

Det krävs förstås mer för att koda intressanta filter, men med denna förklaring, dokumentationen av programmeringsgränssnittet och tillgång till vår källkod, bör du kunna komma igång. Tveka inte att kontakta utvecklarna av &chalk; på IRC eller via e-postlistan.

## Verktyg

Verktyg visas i &chalk;s verktygslåda. Det betyder att det finns begränsat utrymme för nya verktyg: tänk noga efter om en ritoperation inte är tillräckligt för ditt syfte. Verktyg kan använda musen eller styrplattan och tangentbordet på komplexa sätt, vilket ritoperationer inte kan. Det är orsaken till att Duplicera är ett verktyg, medan retuschsprutan är en ritoperation.

Var försiktig med statisk data i verktyget: en ny instans av verktyget skapas för varje indataenhet: mus, penna, radergummi, retuschspruta med mera. Verktyg har delats upp i logiska grupper:

- formgivande ritverktyg (cirkel, rektangel)

- frihandsritverktyg (pensel)

- transformverktyg som ställer till ett lagers geometri

- fyllverktyg (som fyll eller toning)

- vyverktyg (som inte ändrar bildpunkter, men ändrar sättet du ser duken, som zoomning)

- markeringsverktyg (som ändrar markeringsmasken)

Vertygsgränssnittet beskrivs i dokumentationen av programmeringsgränssnittet för `KisTool`. Det finns tre delklasser: `KisToolPaint`, `KisToolNonPaint` och `KisToolShape` (som egentligen är en delklass av `KisToolPaint`) som specialiserar `KisTool` för rituppgifter (dvs. ändra bildpunkter), icke-rituppgifter och rituppgifter för former.

Ett verktyg har en grafisk inställningskomponent, precis som filter. För närvarande visas de grafiska inställningskomponenterna i en flik i ett dockat fönster. Det kan komma att ändras till en rad under huvudmenyn (som då ersätter verktygsraden) för &chalk; 2.0, men för närvarande ska inställningskomponenter konstrueras för att få plats under en flik. Som alltid är det bäst att använda &TQt; Designer för konstruktion av inställningskomponenten.

Ett bra exempel på ett verktyg är stjärnverktyget:

    kis_tool_star.cpp       Makefile.am   tool_star_cursor.png  wdg_tool_star.ui
    kis_tool_star.h        Makefile.in   tool_star.h
    chalktoolstar.desktop  tool_star.cpp  tool_star.png

Som du ser, behöver du två bilder: en för markören och en för verktygslådan. `tool_star.cpp` laddar bara insticksprogrammet, på liknande sätt som vi har sett ovan. Det matnyttiga finns 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;
    }

Konstruktorn skapar det interna namnet, som inte översätts, och anropet till superklassen anger det synliga namnet. Vi laddar också markörbilden och tilldelar värden till ett antal variabler.

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

Metoden `update()` anropas när verktyget väljes. Det är inte en metod i `KisTool`, utan en metod i `KisCanvasObserver`. Dukobservatörer underrättas så fort något ändras i vyn, vilket kan vara användbart för verktyg.

Följande metoder (`buttonPress`, `move` och `buttonRelease`) anropas av &chalk; när inmatningsenheten (mus, penna, radergummi, etc.) trycks ner, flyttas eller släpps upp. Observera att förflyttningshändelser också avges om musknappen inte är nertryckt. Händelserna är inte de vanliga &TQt;-händelserna, utan syntetiska händelser i &chalk;, eftersom vi drar nytta av trick på låg nivå för att få tillräckligt med händelser för att rita jämna linjer. Normalt kastar verktygslådor som &TQt; (och GTK) händelser om de är för upptagna för att hantera dem, och vi vill ha dem alla.

    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() & TQt::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()` är en intern metod i `KisToolStar` som ritar stjärnans kontur. Vi anropar den från metoden `move()` för att ge användaren återmatning om stjärnans storlek och form. Observera att vi använder `TQt::NotROP` rasteroperationen, vilket betyder att anropa `draw()` en andra gång med samma start- och slutpunkt gör att stjärnan tas bort.

    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(TQt::SolidLine);

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

       p.setRasterOp(TQt::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()` är fundamental: Här skapar vi åtgärden som kommer att stoppas in i verktygslådan så att användare verkligen kan välja verktyget. Vi tilldelar också en snabbtangent. Observera att en del programknep används här: kom ihåg att vi skapade en instans av verktyget för varje inmatningsenhet. Det betyder också att vi anropar `setup()` för varje inmatningsenhet och att en åtgärd med samma namn läggs till flera gånger i åtgärdssamlingen. Men allt verkar fungera, så varför bekymra sig?

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

       if (m_action == 0) {
           TDEShortcut shortcut(TQt::Key_Plus);
           shortcut.append(TDEShortcut(TQt::Key_F9));
           m_action = new TDERadioAction(i18n("&Star"),
                                       "tool_star",
                                       shortcut,
                                       this,
                                       TQ_SLOT(activate()),
                                       collection,
                                       name());
           TQ_CHECK_PTR(m_action);

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

Metoden `starCoordinates()` innehåller en del knepig matematik, men den är inte särskilt intressant i beskrivningen av hur man skapar verktygsinsticksprogram.

    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()` anropas för att skapa den grafiska inställningskomponenten som &chalk; visar under fliken. Eftersom det finns ett verktyg per inmatningsenhet och per vy, kan tillståndet hos ett verktyg lagras i verktyget. Metoden anropas bara en gång: den grafiska inställningskomponenten lagras och hämtas nästa gång verktyget aktiveras.

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

       m_optWidget = new WdgToolStar(widget);
       TQ_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;
    }

### Avslutning av verktyg

Verktyg är relativt enkla insticksprogram att skapa. Du måste kombinera gränssnitten `KisTool` och `KisCanvasObserver` för att skapa ett verktyg effektivt.

## Ritoperationer

Ritoperationer är en av de mest uppfinningsrika typer av insticksprogram i Chalk (tillsammans med färgrymder som kan användas som insticksprogram). En ritoperation definierar hur verktyg ändrar bildpunkterna de berör. Retuschspruta, penna utan kantutjämning eller bildpunktspensel med kantutjämning är alla ritoperationer. Men du skulle kunna, med en stor mängd arbete, skapa en ritoperation som läser Corel Paint XML-penseldefinitioner och använder dem för att bestämma hur man ska rita

Ritoperationer instantieras när ett ritverktyg tar emot händelsen `mouseDown` och tas bort när händelsen mouseUp tas emot av ett ritverktyg. Under mellantiden kan ritoperationen hålla reda på tidigare positioner och annan information, som trycknivåer om användaren använder en styrplatta.

Den grundläggande åtgärden för en ritoperation är att ändra bildpunkter vid ett ritverktygs markörposition. Det kan bara göras en gång, eller så kan ritoperationen begära att få utföras med regelbundna intervall, med användning av en tidtagare. Det första fallet är användbart för en pennliknande ritoperation, och det andra naturligtvis för en ritoperation som liknar en retuschspruta.

Ritoperationer kan ha en liten grafisk inställningskomponent som placeras i en verktygsrad. Alltså måste grafiska inställningskomponenter för ritoperationer ha en horisontell layout som inte är högre än en knapp i en verktygsrad, annars skulle &chalk; se mycket konstigt ut.

Låt oss titta på ett enkelt insticksprogram för en ritoperation,, en som visar en viss mängd programbaserad intelligens. För det första finns en fabrik definierad i deklarationsfilen. Fabriken skapar en ritoperation när det aktiva verktyget 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 TQString pixmap() { return ""; }

    };

Fabriken innehåller också `KisID` med det offentliga och privata namnet på ritoperationen, och kan valfritt returnera en punktavbildning. &chalk; kan därefter visa punktavbildningen tillsammans med namnet som en visuell identifikation av ritoperationen. Till exempel skulle ritoperationen målarkniv ha en bild av ett sådant verktyg. Försäkra dig om att ritoperationens privata namn inte råkar i konflikt med en annan ritoperation!

Implementeringen av ritoperationer är mycket rättfram:

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

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

Metoden `paintAt()` är stället där allt händer för ritoperationer. Metoden har två parametrar, den aktuella positionen (som anges med flyttal, inte i hela bildpunkter) och objektet `KisPaintInformation`, som innehåller tryck, x, y, lutning och förflyttningsvektor, och som kan utökas med ytterligare information i framtiden.

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

       KisBrush *brush = m_painter->brush();

En `KisBrush` är representationen av en Gimp penselfil: det vill säga en mask, antingen en enda mask eller en serie masker. I själva verket använder vi inte penseln här, utom för att bestämma ritpunkten 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");
       TQ_CHECK_PTR(dab);

Vi ändrar inte bildpunkterna på en uppritningsenhet direkt: istället skapar vi en liten uppritningsenhet, en dutt, och sammanfogar den med den aktuella uppritningsenheten.

    m_painter->setPressure(info.pressure);

I enlighet med kommentarerna, utför följande kodstycke lite programarbete för att skapa själva dutten. I detta fall ritar vi ett antal linjer. När ritoperationen är klar, kommer linjernas längd, position och tjocklek bero på tryck och färgmängd, och vi har skapat en styv, smetig oljefärgspensel. Men jag har inte haft tid att avsluta detta ännu.

    // 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();

Till sist överför vi dutten med en blocköverföring på den ursprungliga uppritningsenheten och talar om för uppritaren att vi har påverkat en liten rektangel på uppritningsenheten.

    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);
       TQ_CHECK_PTR(op);
       return op;
    }

Det är allt: ritoperationer är enkla och kul!

## Vyinsticksprogram

Vyinsticksprogram är de konstigaste i hela gänget: Ett vyinsticksprogram är en vanlig KPart som kan tillhandahålla en viss mängd användargränssnitt och en del funktioner. Histogramfliken är till exempel ett vyinsticksprogram, liksom rotationsdialogrutan.

## Import- och exportfilter

&chalk; arbetar med den vanliga filterarkitekturen för filer i &koffice;. Det finns en handledning, något gammal, men fortfarande användbar, på: . Det är troligtvis bäst att samarbeta med &chalk;-gruppen vid utveckling av filfilter och att göra utvecklingen i &koffice; filterträd. Observera att du kan prova filter utan att köra &chalk; genom att använda verktyget `koconverter`.

Filter har två sidor: import och export. De är oftast två olika insticksprogram som kan dela viss kod.

De viktiga posterna i `Makefile.am` är:

    service_DATA = chalk_XXX_import.desktop chalk_XXX_export.desktop
    servicedir = $(kde_servicesdir)
    kdelnk_DATA = chalk_XXX.desktop
    kdelnkdir = $(kde_appsdir)/Office
    libchalkXXXimport_la_SOURCES = XXXimport.cpp
    libchalkXXXexport_la_SOURCES = XXXexport.cpp
    METASOURCES = AUTO

Oberoende av om du skapar ett importfilter eller ett exportfilter, är kontentan av arbetet alltid att implementera följande funktion:

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

Det är inställningarna i filen `.desktop` som avgör på vilket sätt ett filter konverterar:

Import:

    X-TDE-Export=application/x-chalk
    X-TDE-Import=image/x-xcf-gimp
    X-TDE-Weight=1
    X-TDE-Library=libchalkXXXimport
    ServiceTypes=KOfficeFilter

Export:

    X-TDE-Export=image/x-xcf-gimp
    X-TDE-Import=application/x-chalk
    ServiceTypes=KOfficeFilter
    Type=Service
    X-TDE-Weight=1
    X-TDE-Library=libchalkXXXexport

Och ja, MIME-typen som är vald i exemplet är en antydan: Snälla, snälla, implemetera ett XCF-filter!

### Import

Det stora problemet med importfilter är förstås koden för att läsa data på disk. Standardkoden för att anropa denna kod är ganska enkel:

Observera: Vi borde verkligen hitta ett sätt att göra det möjligt för &chalk; att behålla en fil öppen och bara läsa data alltefter det behövs, istället för att kopiera hela innehållet till den interna representationen i uppritningsenheten. Men det skulle betyda gränssnitt för datahantering som känner till TIFF-filer och så vidare, och det är för närvarande inte implementerat. Det skulle vara idealiskt om vissa filfilter kunde implementera en klass, preliminärt kallad `KisFileDataManager`, skapa ett objekt av den instansen med den aktuella filen och skicka den till KisDoc. Men &chalk; hanterar lagring per lager, inte per dokument, så det skulle vara en svårt omskrivning.

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

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

       TQString 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;
    }

- Detta är avsett att vara ett importfilter, så om det inte anropas för att konvertera till en bild i &chalk;, är det något som är fel.

- Filterkedjan har redan skapat ett utdatadokument åt oss. Vi måste typkonvertera den till `KisDocM`, eftersom &chalk;-dokument kräver särskilt behandling. Det skulle i själva verket inte vara en dum idé att kontrollera att resultatet av typkonverteringen inte är 0, eftersom om den är det kommer importen att misslyckas.

- Om vi anropar filtret från det grafiska gränssnittet, försöker vi få vyn. Om det finns en vy, kan konverteringskoden försöka uppdatera förloppsraden.

- Filtret har filnamnet på indatafilen åt oss.

- `KisDoc` måste förberedas för import. Vissa inställningar initieras och ångra inaktiveras. Annars skulle du kunna ångra tillägg av lager som utförs av importfiltret, och det är ett konstigt beteende.

- Jag har valt att implementera själva importkoden i en separat klass som jag instantierar här. Du kan också lägga all din kod direkt i den här metoden, men det skulle vara lite stökigt.

- Min importkod returnerar en statuskod, som jag sedan kan använda för att ange status för importfiltret. &koffice; tar hand om att visa felmeddelanden.

- Om vi har lyckats skapa `KisImage` sätter vi dokumentets aktuella bild till vår nyskapade bild. Därefter är vi klara: `return KoFilter::OK;`.