# &krita; pluginate arendamine

## Sissejuhatus

&krita; on tänu pluginatele lõputult laiendatav. Pluginateks on tööriistad, filtrid, suur osa kasutajaliidesest ning isegi värviruumid. &krita; kasutab kuut tüüpi pluginaid:

- värviruumid — kanalite kirjeldamiseks, millest koosneb üks piksel

- tööriistad — kõik, mida saab teha hiirega või graafikalauaga

- joonistamisoperatsioonid — tööriistadele kaasatavad joonistamisefektid

- pildifiltrid — kõigi pikslite või ka lihtsalt kihi valitud pikslite muutmiseks

- vaatepluginad — Krita kasutajaliidese laiendamiseks uute dialoogide, palettide ja operatsioonidega

- import/eksportfiltrid — igat laadi pildivormingute lugemiseks ja kirjutamiseks

&krita; ise koosneb kolmest teegist ja kataloogis mõne ühise tugiklassiga: kritacolor, kritaimage ja kritaui. Objekte tuvastab &krita;s `KisID`, mis on unikaalse tõlkimata stringi (kasutatakse näiteks salvestamisel) ja graafilise kasutajaliidese jaoks tõlgitud stringi kombinatsioon.

Sõnake ühilduvuse kohta: &krita; on endiselt arendamisjärgus. &krita; 1.5 ja 1.6 vahel pole ette näha kuigi palju API muudatusi, aga mõned võivad siiski olla. &krita; 1.6 ja 2.0 vahele jääb üleminek &Qt;3 pealt &Qt;4 peale, &kde;3 pealt &kde;4 peale, `automake`'i pealt `cmake`'i peale, mis tähendab väga suuri muudatusi. Kui arendad pluginat &krita; tarbeks ja pead paremaks teha seda &krita; Subversioni hoidlas, võime me aidata sind portimisel. Muudatused võivad muuta ka käesoleva dokumendi vähemal või rohkemal määral iganenuks. Kontrolli alati oma süsteemi paigaldatud uusimat API dokumentatsiooni või päisefaile.

### KritaColor

Esimene teek on kritacolor. See laadib värviruumipluginad.

Värviruumiplugin peab teostama `KisColorSpace` abstraktse klassi või kui uue värviruumi põhiomadusi teostab `lcms` (), siis laiendama klassi `KisAbstractColorSpace`. Teeki kritacolor saavad kasutada teised rakendused ja see ei sõltu &koffice;'ist.

### KritaImage

Teek libkritaimage laadib filtrid ja joonistamisoperatsioonide pluginad ning vastutav pildiandmetega töötamise eest: pikslite muutmine, komposiit- ja joonistamisoperatsioonid. Ka pintsleid, palette, üleminekuid ja mustreid laadib libkritaimage. Meie kindel eesmärk on muuta libkritaimage sõltumatuks &koffice;'ist, kuid praegu jagame me veel &koffice;'iga üleminekute laadimise koodi.

Praegu pole väga lihtne lisada &krita; uut tüüpi ressursse, näiteks pintsleid, palette, üleminekuid ja mustreid. (Uute pintslite, palettide, üleminekute ja mustrite lisamine on loomulikult lihtne.) &krita; järgib selles osas projekti Create () suuniseid. Photoshopi pintslifaili vormingu toetuse lisamine vajab libkritaimage'i häkkimist, GIMP-i pintslite lisamine samas aga mitte.

`KritaImage` laadib järgmist tüüpi pluginad:

- &krita; filtrid peavad laiendama ja teostama abstraktse klassi `KisFilter`, `KisFilterConfiguration` ja võimaluse korral `KisFilterConfigurationWidget`. Filtri näiteks on teravustamismask.

- Joonistamisoperatsioonid on operatsioonide kogumid, mida saavad kasutada joonistamistööriistad, näiteks vabakäsi või ring. Joonistamisoperatsioonide näiteks on pliiats, pihusti või kustutaja. Joonistamisoperatsioonid peavad laiendama `KisPaintop` baasklassi. Uute joonistamisoperatsioonide näiteks on kriidipintsel, õlimaalipintsel või keerukas programmeeritav pintsel.

### KritaUI

Teek libkritaui laadib tööriistad ja vaatepluginad. Teek on &koffice;'i komponent, kuid sisaldab ka mitmeid vidinaid, mis on abiks graafikarakendustele. Võimalik, et see teek jagatakse 2.0 ajaks teekideks kritapart ja kritaui. Praegu ei ole skriptikirjutajatel sellele teegile ligipääsu ning pluginakirjutajatel on lubatud seda kasutada ainult tööriistade või vaatepluginate kirjutamisel. `KritaUI` laadib järgmist tüüpi pluginad:

- Tööriistad tulenevad klassist `KisTool` või mõnest spetsiaalsest tööriistade baasklassist, näiteks `KisToolPaint`, `KisToolNonPaint` või `KisToolFreehand`. Uus tööriist võib olla esiplaani objekti valimise tööriist. Joonistamistööriistad (nende hulka käivad tööriistad, mis joonistavad valikuga) võivad kasutada iga joonistamisoperatsiooni määramaks, kuidas piksleid muudetakse.

- Vaatepluginad on tavalised KParts, mis kasutavad `kxmlgui` enda sobitamiseks &krita; kasutajaliidesesse. Menüükirjed, dialoogid, tööriistaribad — mis tahes kasutajaliidese laiendus võib olla vaateplugin. Õigupoolest on üsna olulisi funktsioone, näiteks &krita; skriptitoetus, kirja pandud vaatepluginana.

### Import/eksportfiltrid

Import/eksportfiltrid on &koffice;'i filtrid, `KoFilter` alamklassid. Filtrid loevad ja kirjutavad pildiandmeid mis tahes pildivormingutest ja pildivormingutesse. Uue &krita; import/eksportfiltri näiteks on PDF-filter. Filtreid laadivad &koffice;'i teegid.

## Pluginate loomine

Pluginad kirjutatakse C++ keeles ning need võivad kasutada kogu &kde;, &Qt; ja &krita; API-t. Ainult vaatepluginad peavad kasutama &koffice;'i API-t. Aga ära muretse: &krita; API on väga selge ja päris ulatuslikult dokumenteeritud (vaba tarkvara kohta) ning oma esimese filtri koodi kirjutamine üsna lihtne.

Kui sa ei soovi C++ keelt kasutada, võid kirjutada skriptid Pythoni või Ruby keeles. See on siiski täiesti teine asi ning praegu ei saa kirjutada tööriistu, värviruume, joonistamisoperatsioone ega import/eksportfiltreid skriptidena.

&krita; pluginad kasutavad laadimiseks &kde; komponentide mehhanismi (KPart), mistõttu asjakohane on ka komponentide dokumentatsioon, mille leiab aadressil .

Sinu distributsioon peaks olema paigaldanud vajalikud päisefailid koos &krita;ga või siis jaganud päisefailid &koffice;'i või &krita; arenduspaketti (devel). &krita; avaliku API dokumentatsiooni leiab aadressil .

### Automake (ja CMake)

&kde; 3.x ja seega ka &koffice; 1.5 ja 1.6 kasutavad `automake`'i. &kde; 4.0 ja &koffice; 2.0 kasutavad `cmake`'i. Käesolev tutvustus kirjeldab pluginate loomist `automake`'iga.

Pluginad on &kde; moodulid ja nii tuleb neid ka sildistada failis `Makefile.am`. Filtrid, tööriistad, joonistamisoperatsioonid, värviruumid ja import/eksportfiltrid vajavad `.desktop`-faile; vaatepluginad lisaks veel KXMLGui faili `pluginname.rc`. Lihtsaim viis alustada on teha väljavõte projektist krita-plugins &koffice;'i Subversioni hoidlas ning kasutada seda oma projekti baasina. Me kavatseme valmistada &krita; pluginamallid KDevelopi tarbeks, kuid pole seni veel jõudnud seda teha.

#### `Makefile.am`

Vaatame plugina mooduli kondikava. Kõigepealt `Makefile.am`. Seda kasutab &kde; makefile'i genereerimiseks, mis ehitab plugina:

    kde_services_DATA = kritaLIBRARYNAME.desktop

    INCLUDES = $(all_includes)

    kritaLIBRARYNAME_la_SOURCES = sourcefile1.cc sourcefile2.cc

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

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

    kritaextensioncolorsfilters_la_METASOURCES = AUTO

See on filtriplugina makefile. Asenda LIBRARYNAME oma töö nimega ja asi valmis.

Kui sinu plugin on vaateplugin, tuleb paigaldada ka `.rc`-fail menüüribade ja tööriistaribade kirjetega. Samuti võib olla vajalik paigaldada kursorid ja ikoonid. Seda kõike saab teha tavapärase &kde; `Makefile.am` maagiaga:

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

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

#### Töölauafailid

`.desktop`-fail annab teada plugina tüübi:

    [Desktop Entry]
    Encoding=UTF-8
    Icon=
    Name=Kasutajale nähtav nimi
    ServiceTypes=Krita/Filter
    Type=Service
    X-KDE-Library=kritaLIBRARYNAME
    X-KDE-Version=2

Võimalikud teenusetüübid (ServiceTypes) on järgmised:

- Krita/Filter

- Krita/Paintop

- Krita/ViewPlugin

- Krita/Tool

- Krita/ColorSpace

Failide import- ja eksportfiltrid kasutavad &koffice;'i üldist filtriraamistikku ja neist tuleb eraldi juttu.

#### Trafarett

Vaja läheb ka veidi trafaretset koodi, mille &kde; komponentide raamistik kutsub välja plugina initsialiseerimiseks — päisefail ja teostusfail.

Päisefail:

    #ifndef TOOL_STAR_H_
    #define TOOL_STAR_H_

    #include <kparts/plugin.h>

    /**
    * A module that provides a star tool.
    */
    class ToolStar : public KParts::Plugin
    {
       Q_OBJECT
    public:
       ToolStar(QObject *parent, const char *name, const QStringList &);
       virtual ~ToolStar();

    };

    #endif // TOOL_STAR_H_

Ja teostusfail:

    #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"

#### Registrid

Tööriistad laadib tööriistaregister ja need registreerivad ennast tööriistaregistris. Pluginad, nagu ka tööriistad, filtrid ja joonistamisoperatsioonid laaditakse ainult üks kord; vaatepluginad laaditakse iga loodava vaate korral. Arvesta, et me registreerime üldiselt vabrikuid (factory). Näiteks tööriistade korral luuakse tööriista uus isend iga viida jaoks (hiir, stiilus, kustutaja). Uus joonistamisoperatsioon luuakse alati, kui tööriist saab hiirenupu vajutamise sündmuse.

Filtrid kutsuvad välja filtriregistri:

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

Joonistusoperatsioonid joonistusoperatsioonide registri:

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

Värviruumid värviruumide registri (mõningate komplikatsioonidega):

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

Vaatepluginad ennast ei registreeri ning nad saavad ligipääsu `KisView`-objektile:

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

Arvesta, et see tähendab, et vaateplugin luuakse igale vaatele, mille kasutaja loob; vaate poolitamine tähendab kõigi vaatepluginate taaslaadimist.

#### Pluginate versioonid

&krita; laadib pluginad versiooniga `X-KDE-Version=2`, mille määrab `.desktop`-fail. &krita; 1.6 pluginad on arvatavasti binaarselt ühildumatud 1.5 pluginatega ja vajavad versiooni 3. &krita; 2.0 pluginad vajavad versiooni 3. Jah, see pole just täiesti loogiline.

## Värviruumid

Värviruumid teostavad `KisColorSpace` ehtsa virtuaalse klassi. Värviruume on kaht tüüpi: need, mis võivad värviruumide teisendamiseks kasutada `lcms`'i ja need, mis on `lcms`'i jaoks liiga veidrad. Esimese näited on cmyk, rgb, yuv. Teise näiteks on vesivärvid. Värviruume, mis kasutavad `lcms`'i, saab tuletada klassit `KisAbstractColorSpace` või mõnest baasklassist, mis on mõeldud teatud bittide arvuga kanalile.

Värviruumi teostamine on üpris lihtne. Põhimõtteliselt on värviruum lihtsalt baidimassiiv. Baitide tõlgendamine on värviruumi ülesanne. Näiteks piksel 16-bitises GrayA värviruumis koosneb neljast baidist: kaks baiti halli väärtuse ja kaks baiti alfa väärtuse jaoks. Sa võid vabalt kasutada oma värviruumi teostuses struktuure piksli mälupaigutuse jaoks, aga seda esindust ei ekspordita. &krita; saab sellest, millistest kanalitest ja kanalitüüpidest sinu värviruumi pikslid koosnevad, teada ainult klassi `KisChannelInfo` kaudu.

Filtrid ja joonistamisoperatsioonid kasutavad oma tööks arvukaid meetodeid, mida pakub `KisColorSpace`. Paljudel juhtudel toimib vaikimis teostus klassis `KisAbstractColorSpace`, kuid see on aeglasem kui kohandatud teostus omaenda värviruumis, sest `KisAbstractColorSpace` teisendab kõik pikslid 16-bitiseks L*a*b-iks ja tagasi.

### `KisChannelInfo`

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

See klass kirjeldab kanaleid, millest koosneb üks piksel antud värviruumis. Kanalil on järgmised olulised tunnused:

- nimi, mida kuvatakse kasutajaliideses

- asukoht: bait, kus baidid tähistavad antud kanali algust pikslis.

- tüüp: värv. alfa, substants või substraat. Värv on puhas värv, alfa läbipaistvus, substants tähistab pigmendi või millegi sellise kogust, substraat tähistab lõuendit.

- väärtusetüüp: bait, lühike või pikk täisarv, murdarv või midagi muud.

- suurus: antud kanali baitide arv

- värv: antud kanali `QColor` esindus kasutajaliidese tarbeks, näiteks histogrammis.

- lühend kasutajaliidese tarbeks, kui seal napib ruumi

### `KisCompositeOp`

Uue värvi saamiseks on võimalik piksleid mitmel moel kombineerida. Klass `KisCompositeOp` kirjeldab neist enamikku: see kogum ei ole kuigi lihtsalt laiendatav, kui mitte häkkida teeki kritacolor.

Värviruumi plugin võib toetada võimalike komposiitoperatsioonide mis tahes alamhulka, aga selles peab alati sisalduma "OVER" (sama mis "NORMAL") ja "COPY". Ülejäänud on enam-vähem suvalised, ehkki: mida rohkem, seda parem.

### `KisColorSpace`

Ehtsa virtuaalse klassi `KisColorSpace` meetodid võib jagada mitmesse rühma: teisendamine, tuvastamine ja manipuleerimine.

Kõik klassid peavad suutma teisendada pikslit 8-bitisest RGB-st ja 8-bitisesse RGB-sse (s.t. `QColor`), võimaluse korral ka 16-bitisest L*a*b-ist ja 16- bitisesse L*a*b-i. Lisaks on ka meetod, mis võimaldab teisendada mis tahes värviruumist aktiivsesse värviruumi.

Värviruume kirjeldavad `KisChannelInfo` vektor, kanalite arv, baitide arv ühes pikslis, High Dynamic Range piltide toetus või selle puudumine ja veel mitmed tunnused.

Manipuleerimise näiteks on kahe piksli kombineerimine uueks piksliks: bitBlt, pikslite tumendamine või konvolveerimine.

Kõiki meetodeid, mida värviruumis tuleb teostada, kirjeldab põhjalikult API dokumentatsioon.

Klass `KisAbstractColorSpace` teostab paljud `KisColorSpace` virtuaalsed meetodid `lcms` teegi funktsioonide abil. Klassi `KisAbstractColorSpace` kohal asuvad baasvärviruumiklassid 8- ja 16-bitistele täisarvulistele ning 16- ja 31-bitistele murdarvulistele värviruumidele, mis kirjeldavad bitisügavuste vahel liikumise ühiseid operatsioone.

## Filtrid

Filtrid on pluginad, mis uurivad piksleid kihis ja seejärel muudavad neid. Kuigi &krita; kasutab pikslite salvestamiseks tõhusalt klotsmälu taustaprogrammi, ei pruugi filtri kirjutaja selle pärast muretseda. Kirjutades filtripluginat &Java; pildi-API-le, Photoshopile või GIMP-ile, tuleb muret tunda klotside servade pärast ja klotsid kokku klopsida: &krita; peidab teostuse detailid.

Arvesta, et teoreetiliselt on hõlpus asendada praegune klots-pildiandmete salvestamine taustaprogramm mõne muuga, kuid jõudluse huvides ei ole see taustaprogramm ise praegu tegelikult plugin.

&krita; kasutab piksliväärtuste lugemiseks ja kirjutamiseks iteraatoreid. Teine võimalus on lugeda piksliplokk mälupuhvrisse, seda töödelda ja siis taas plokina tagasi kirjutada. Kuid see ei pruugi olla tingimata tõhusam, õieti võib see isegi olla aeglasem kui iteraatorite kasutamine, aga muidugi on see omajagu ka maitseasi. Vaata lähemalt API dokumentatsiooni.

&krita; pildid koosnevad kihtidest, mida praegu on nelja tüüpi: joonistamiskihid, grupikihid, kohandamiskihid (need sisaldavad filtrit, mis rakendatakse dünaamiliselt kohandamiskihi all asuvatele kihtidele) ja komponendikihid. Filtrid toimivad alati joonistamiskihil. Joonistamiskihid sisaldavad joonistamisseadmeid klassist `KisPaintDevice`. Joonistamisseade omakorda tagab ligipääsu tegelikele pikslitele.

`PaintDevice` edastatakse üldiselt jagatud viitadesse mähituna. Jagatud viit peab arvet, mitmes kohas joonistamisseadet parajasti kasutatakse ja kustutab joonistamisseadme, kui seda enam kusagil ei kasutata. Joonistamiseadme jagatud viida versiooni tunneb ära sufiksi `SP` järgi (see on lühend sõnadest shared pointer). Arvesta aga seda, et mitte kunagi ei tohi otseselt kustutada `KisPaintDeviceSP`.

Uurime üht lihtsat filtrit, mis inverteerib piksli. Filtri kood asub kataloogis `koffice/krita/plugins/filters/example`. Põhimeetod on

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

Funktsioonile edastatakse kaks joonistusseadet, konfiguratsiooniobjekt (mida selles lihtsas filtris ei kasutata) ja `rect`. `rect` kirjeldab joonistusseadme ala, millel filter tegutseb. Seda ala kirjeldavad täisarvud, mis tähendab, et pikslisisene täpsus puudub.

Joonistusseade `src` on lugemiseks, `dst` kirjutamiseks. Need parameetrid võivad tegelikkuses osutada ühele ja samale joonistusseadmele, aga ka erinevatele. (Märkus: võimalik, et tulevikus ongi ainult üks joonistusseade.)

Vaatame nüüd koodi rida realt:

    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(); // Must be called even if you don't really support progression
    }

See loob iteraatori olemasolevate pikslite lugemiseks. Krital on kolme tüüpi iteraatoreid: rõhtne, püstine ja ristkülikuline. Viimane ehk rect-iteraator kasutab pildiandmete mõttes kõige tõhusamat viisi, kuid ei taga kuidagi järgmise tagastatava piksli asukohta. See tähendab, et sa ei saa olla kindel, et piksel, mille hangid, asub selle piksli naabruses, mille just said. Rõht- ja püstrea iteraatorid tagavad tagastatavate pikslite asukoha.

(2) Loome sihtiteraatori, andes `write` väärtuseks `true`. See tähendab, et kui sihtjoonistusseade on väiksem kui ristkülik, mida me kirjutame, suurendatakse seda automaatselt kõigi pikslite sobitamiseks, üle mille me itereerime. Arvesta, et siin võib peituda viga: kui `src` ja `dst` ei ole üks ja sama seade, on üsna võimalik, et iteraatorite tagastatavad pikslid ei vasta üksteisele. Iga positsiooni korral iteraatoris võib `src` näiteks olla asukohas 165,200, samal ajal kui `dst` on asukohas 20,8 — ja nii võib kopeerimine, mille me allpool sooritame, moonutada pilti...

Soovid teada, kui piksel on valitud? See on lihtne — kasuta meetodit `isSelected`. Kuid valitus ei ole piksli binaaromadus, piksel võib olla poolvalitud, vaevu valitud või peaaegu täielikult valitud. Selle väärtuse võib saada ka iteraatorist. Valikud on tegelikult maskijoonistusseade vahemikuga 0 kuni 255, kus 0 on täiesti valimata ja 255 täielikult valitud. Iteraatoril on kaks meetodit: `isSelected()` ja `selectedNess()`. Esimene tagastab TÕENE, kui piksel on mingilgi määral valitud (s.t. maksi väärtus on suurem kui 1), teine tagastab maskiväärtuse.

Nagu eespool märgitud, peidab see `memcpy` endas võimalikku suurt viga... `rawData()` tagastab piksli aktiivset olekut näitava baidimassiivi, `oldRawData()` tagastab baidimassiivi nii nagu see oli enne seda, kui me lõime iteraatori. Siiski võime me siin kopeerida vale piksli. Tegelikkuses seda väga sageli ei juhtu, kui just pole juba olemas `dst`, mis erineb seadmest `src`.

Aga see on õige: selle asemel, et välja selgitada, milline bait esindab millist kanalit, kasutame me funktsiooni, mida pakuvad kõik värviruumid aktiivse piksli teisendamiseks. Värviruumides on hulk pikslioperatsioone, mida saab ära kasutada.

See ei ole filtri loomise juures veel kõik. Filtritel on veel kaks olulist komponenti: konfiguratsiooniobjekt ja konfiguratsioonividin. Need kaks toimivad tihedas koostöös. Konfiguratsioonividin loob konfiguratsiooniobjekti, kuid seda võib ka täita juba varem olemas olnud konfiguratsiooniobjekt. Konfiguratsiooniobjektid võivad esitada ennast XML-ina ja neid saab luua XML-ist. See muudabki kohandamiskihid võimalikuks.

### Iteraatorid

Iteraatoreid on kolme tüüpi:

- Rõhtread

- Püstread

- Ristkülikiteraatorid

Rõht- ja püstreaiteraatoritel on meetod iteraatori liigutamiseks järgmisse ritta või veergu: `nextRow()` ja `nextCol()`. Nende kasutamine on märksa kiirem kui uue iteraatori loomine igale reale või veerule.

Iteraatorid on &krita;s lõimekindlad, mii et töö saab jagada mitme lõime vahel. &krita; tulevastes versioonides on kasutusel meetod `supportsThreading()`, mis määrab, kas filtrit saab rakendada pildi tükkidele (&ie; kõiki piksleid muudetakse iseseisvalt, mitte aga ei muudeta mingi väärtuse võrra, mis määratakse pildi kõigi pikslite uurimise põhjal), ning selle põhjal jagab filtri täitmise automaatselt lõimedesse.

### `KisFilterConfiguration`

`KisFilterConfiguration` on struktuur, mida kasutatakse filtri seadistuste salvestamiseks kettale, näiteks kohandamiskihtide korral. Skriptiplugin kasutab omadustekaarti, mis `KisFilterConfiguration` taustal muudab võimalikuks filtreid skriptida. Filtrid võivad pakkuda kohandatud vidina, mida &krita; näitab filtrigaleriis, filtri eelvaatluse dialoogis või filtriga joonistamise tööriista tööriistavalikute kaardil.

Näide õlimaalifiltri põhjal:

    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`

Enamikku filtreid saavad kasutajad kohandada. Võimalik on luua konfiguratsioonividin, mida Krita kasutab iga kord, kui filtrit kasutatakse. Näide:

Õlimaali dialoog Õlimaali dialoog

Õlimaali dialoog

Pane tähele, et sinu teha on ainult dialoogi vasak külg: ülejäänu eest kannab hoolt &krita; ise. Seadistustevidinat saab luua kolmel moel:

- Loo &Qt; Disaineriga vidinabaas ja muuda see oma filtri alamklassiks

- Kasuta mõnda lihtsat vidinat, mis näitavad mitmeid liugureid täisarvude, reaalarvude või tõeväärtuste loenditega. Need on abiks, kui sinu filtrit saab samamoodi, nagu ülaltoodud pildil nähtavat filtrit, seadistada mitmete täisarvude, reaalarvude või täeväärtustega. Vaata `KisMultiIntegerFilterWidget`, `KisMultiDoubleFilterWidget` ja `KisMultiBoolFilterWidget` API dokumentatsiooni.

- Kirjuta vidina kood ise. See ei ole küll soovitatav, nii et kui sa seda teed, aga soovid, et sinu filter läheks &krita; ametlikku väljalaskesse, siis võid oodata, et sul palutakse asendada oma käsitsi kirjutatud vidin &Qt; Disaineri vidinaga.

Õlimaalifilter kasutab mitme täisarvuga vidinat:

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

Siin on näha, kuidas asi töötab: vektor täidetakse täisarvuliste parameetritega ja luuakse vidin. Meetod `configuration()` uurib vidinat ja loob õige filtri konfiguratsiooniobjekti, milleks antud juhul on mõistagi `KisOilPaintFilterConfiguration`. Meetod `listOfExamplesConfiguration` tagastab loendi näidiskonfiguratsiooniobjektidega filtrigalerii dialoogi jaoks.

### Filtrite kokkuvõte

Filtrite koodi kirjutamise juures on loomulikult veel palju põnevat, aga antud selgituste, API dokumentatsiooni ja ligipääsu varal meie lähtekoodile peaks olema võimalik vähemalt alustada. Vajaduse korral ära kõhkle võtmast ühendust &krita; arendajatega IRC-s või postiloendis.

## Tööriistad

Tööriistad on näha &krita; tööriistakastis. See tähendab, et uutele tööriistadele on vaid piiratult ruumi — kaalu hoolikalt, kas sinu eesmärke ei aita täita joonistamisoperatsioon. Tööriistad võivad kasutada hiirt ja klaviatuuri väga mitmel moel, mis joonistamisoperatsioonidele pole jõukohane. Sel põhjusel on näiteks kloonimine tööriist, pihusti aga joonistamisoperatsioon.

Ole ettevaatlik staatiliste andmetega oma tööriistas: sinu tööriista uus isend luuakse iga sisendseadme jaoks, olgu see hiir, stiilus, kustutaja, pihusti või mis tahes muu. Tööriistad jagunevad loogilistesse rühmadesse:

- kujundi joonistamise tööriistad (ring, ristkülik)

- vabakäejoonistamise tööriistad (pintsel)

- teisendustööriistad (muudavad kihi geomeetriat)

- täitmistööriistad (näiteks üleminek)

- vaatetööriistad (ei muuda piksleid, vaid lõuendi kuvamist, näiteks suurendust)

- valikutööriistad (muudavad valikumaski)

Tööriistaliidest kirjeldab `KisTool` API dokumentatsioon. On kolm alamklassi `KisToolPaint`, `KisToolNonPaint` ja `KisToolShape` (mis tegelikult on `KisToolPaint` alamklass), mis annavad `KisTool`'ile spetsiaalseid omadusi joonistamisülesanneteks (s.t. pikslite muutmiseks), mittejoonistamisülesanneteks ja kujundi joonistamise ülesanneteks.

Tööriistal on nagu filtrilgi valikuvidin. Praegu kuvatakse valikuvidinaid dokkakna kaardil. Võimalik, et &krita; 2.0 ajaks seatakse need ribale peamenüü alla (mis asendab siis tööriistariba), aga praegu tuleb veel vidin luua nii, et see sobiks kaardile. Ka valikuvidina loomiseks on kõige parem mõte kasutada &Qt; Disainerit.

Tööriista hea näide on tähetööriist:

    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

Nagu näha, läheb vaja kaht pilti: üks kursori ja üks tööriistakasti jaoks. `tool_star.cc` on lihtsalt plugina laadur, selline nagu eespoolgi nähtud. Põhiasi on aga teostus:

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

Konstruktor määrab sisemise nime — mida ei tõlgita — ja ülemklassi väljakutse nähtava nime. Me laadime ka kursoripildi ja määrame mitu muutujat.

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

Meetod `update()` kutsutakse välja tööriista valimisel. See ei ole mitte `KisTool`, vaid `KisCanvasObserver` meetod. Lõuendivaatlejad saavad alati märguande, kui vaates midagi muutub, mis on tööriistade puhul väga hea.

Järgmised meetodid (`buttonPress`, `move` ja `buttonRelease`) kutsub välja &krita;, kui sisendseadet (hiir, stiilus, kustutaja) vajutatakse, liigutatakse või vabastatakse. Pane tähele, et liikumissündmuse saab ka siis, kui hiirenuppu ei vajutata. Sündmused ei ole tavapärased &Qt; sündmused, vaid sünteetilised &krita; sündmused, sest meil on vaja väga sügavatasemelist trikitamist, et sündmusi oleks piisavalt korraliku joone joonistamiseks. Vaikimisi loobuvad sellised tööriistakomplektid nagu &Qt; (ja ka GTK) sündmustest, kui nad on liiga hõivatud nendega tegelemiseks, meie aga soovime neid kõiki.

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

Meetod `draw()` on `KisToolStar` sisemine meetod ja joonistab tähe kontuuri. Me kutsume selle välja meetodist `move()`, et anda kasutajale tagasisidet tähe suuruse ja kuju kohta. Pane tähele, et me kasutame `Qt::NotROP` rasteroperatsiooni, mis tähendab, et `draw()` teistkordne väljakutsumine sama algus- ja lõpp-punktiga eelnevalt joonistatud täht kustutatakse.

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

Meetod `setup()` on oluline: sellega luuakse toiming, mis lisatakse tööriistakasti, et kasutaja saaks ka tegelikult tööriista valida. Me omistame ka kiirklahvi. Pane tähele, et siin toimub kerge häkkimine: tuleta meelde, et me loome tööriista isendi igale sisendseadmele. See tähendab ka seda, et me kutsume `setup()` v'lja iga sisendseadme jaoks ja see tähendab, et sama nimega toiming lisatakse mitu korda toimingute kogusse. Aga kõik tundub töötavat, nii et milleks muretseda?

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

Meetod `starCoordinates()` sisaldab veidi keerukat matemaatikat — aga see pole eriti tähtis teema juures, kuidas luua tööriistapluginaid.

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

Meetod `createOptionWidget()` kutsutakse välja valikuvidina loomiseks, mida &krita; näitab kaardil. Et töööriist on iga sisendseadme iga vaate jaoks, tuleb tööriista olek hoida tööriistas. Seda meetodit kutsutakse välja ainult üks kord: valikuvidin salvestatakse ja hangitakse uuesti järgmine kord, kui tööriist aktiveeritakse.

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

### Tööriistade kokkuvõte

Tööriistad on üsna lihtsasti loodavad pluginad. Nende loomiseks tuleb lihtsalt konbimeerida `KisTool` ja `KisCanvasObserver` liidesed.

## Joonistamisoperatsioonid

Joonistamisoperatsioonid on Krita ühed kõige innovaatilisemad pluginad (koos värviruumide pluginatega). Joonistamisoperatsioon kirjeldab, kuidas tööriistad muudavad piksleid, mida nad puudutavad. Joonistamisoperatsioonid on näiteks pihusti, pliiats või pintsel. Kuid saab ka — tublisti vaeva nähes — luua joonistamisoperatsioone, mis loevad Corel Painteri XML-pintslikirjeldusi ja kasutavad neid määramaks, kuidas joonistada.

Joonistamisoperatsioonid algväärtustatakse, kui joonistamistööriist saab `mouseDown` sündmuse, ja kustutatakse, kui joonistamistööriist saab mouseUp sündmuse. Vahepeal jälgib joonistamisoperatsioon aga eelnevaid positsioone ja muid andmeid, näiteks survet, kui kasutaja pruugib graafikalauda.

Joonistamisoperatsiooni baasoperatsioon on muuta piksleid joonistamistööriista kursori asukohas. Seda saab teha ainult ühe korra või siis taimeri abil lasta joonistamisoperatsiooni sooritada kindla ajavahemiku tagant. Esimene on tulus pliiatsitüüpi joonistamisoperatsioonide korral, teine mõistagi pihustitüüpi joonistamisoperatsioonide puhul.

Joonistamisoperatsioonidel võib olla väike konfiguratsioonividin, mis asetatakse tööriistaribale. Sestap vajavad joonistamisoperatsiooni konfiguratsioonividinad vidinate rõhtsat paigutamist, mis ei oleks kõrgem kui tööriistariba nupp. Vastasel korral võtab &krita; üsna kummalise välimuse.

Vaatleme üht lihtsat joonistamisoperatsiooni pluginat, mis siiski ilmutab teatud programmeerimisnippe. Kõigepealt tuleb päisefailis määrata vabrik (factory). See loob joonistamisoperatsiooni, kui aktiivne tööriist seda vajab:

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

    };

Vabrik sisaldab ka `KisID` joonistamisoperatsiooni avaliku ja privaatnimega — kontrolli, et sinu joonistamisoperatsiooni privaatnimi ei kattuks mõne muu joonistamisoperatsiooni omaga! — ja võib vajaduse korral tagastada pikselrastri. &krita; näitab seejärel pikselrastrit koos nimega, mis aitab joonistamisoperatsiooni visuaalselt tuvastada.

Joonistamisoperatsiooni teostus on väga lihtne ja selge:

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

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

Meetod `paintAt()` saab kaks parameetrit: aktiivne asukoht (murdarvuna, mitte täispikslites) ja `KisPaintInformation` objekt, mis sisaldab survet, X- ja Y-kallet ja liikumisvektorit ning tulevikus vahest muudki teavet.

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

       KisBrush *brush = m_painter->brush();

`KisBrush` on GIMP-i pintslifaili esindus: see on mask, olgu siis üks või mitme maski seeria. Tegelikult me siin pintslit ei kasuta, völja arvatud tulipunkti määramiseks kursori all.

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

Me ei muuda joonistusseadme piksleid vahetult, vaid loome väikse joonistusseadme 'dab' ja kombineerime selle aktiivse joonistusseadmega.

    m_painter->setPressure(info.pressure);

Nagu kommentaarid ütlevad, on järgnev kood mõeldud tegeliku dab'i loomiseks. antud juhul joonistame mitu joont. Kui joonistamisoperatsiooniga on ühel pool, sõltuvad joonte pikkus, asukoht ja jämedus survest ning me loome paksult katva õlimaalipintsli. Aga selleks pole mul veel aega olnud.

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

Lõpuks blt'ime dab'i algupärasele joonistuseadmele ja teatame joonistajale, et me oleme värvinud joonistusseadmel väikse ristküliku.

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

See ongi kõik: joonistamisoperatsioonid on lihtsad ja lõbusad!

## Vaatepluginad

Vaatepluginad on üpris veidrad asjad: vaateplugin on tavaline KDE komponent (KPart), mis võib pakkuda kasutajaliidest ja teatud funktsionaalsust. Vaatepluginad on näiteks histogrammi kaart või pööramisdialoog.

## Import/eksportfiltrid

&krita; kasutab tavalist &koffice;'i failifiltri arhitektuuri. Selle kohta leidub küll veidi vananenud, aga siiski kasulik tutvustus aadressil . Tõenäoliselt on mõistlik teha koostööd &krita; meeskonnaga, kui soovid luua failifiltreid, ning koondada ona arendustegevus &koffice;'i filtripuusse. Pane tähele, et filtreid saab testida ka ilma &krita;t käivitamata, kasutades utiliiti `koconverter`.

Filtritel on kaks poolt: import ja eksport. Tavaliselt on need kaks erinevat pluginat, millel on teatud määral ühine kood.

Olulised `Makefile.am` kirjed on järgmised:

    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

Sõltumata sellest, kas lood import- või eksportfiltrit, tuleb nagunii teostada järgmine funktsioon:

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

Seadistused `.desktop`-failides määravad, millises suunas filter teisendab:

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

Ja muidugi on näites toodud MIME tüüp korralik vihje: soovib äkki keegi XCF-filtri teoks teha?

### Import

Importfiltri suurim probleem on mõistagi kood, millega lugeda andmeid kettalt. Koodi väljakutsumine on üsna lihtne:

Märkus: me peame tõesti leidma lahenduse, kuidas &krita; hoiab faili avatuna ja loeb ainult neid andmeid, mida vaja, mitte aga ei kopeeri kogu sisu sisemise joonistusseadme esindusele. Aga see tähendab andmehalduri taustaprogrammi, mis tunneb TIFF-faile ja muud sellist ning praegu pole seda teostatud. Oleks ideaalne, kui mõned failifiltrid teostaksid klassi, mille provisoorne nimi võiks olla `KisFileDataManager`, looksid selle isendi objekt aktiivse failiga ja edastaksid selle KisDoc'ile. Aga &krita; haldab salvestamist kihtide, mitte dokumendi kaupa, nii et see on päris keeruline.

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

See peab olema importfilter, nii et kui seda ei kutsuta välja teisendamiseks &krita; pildiks, on midagi valesti.

Filtriahel on juba loonud meile väljunddokumendi. Me peame saatma selle `KisDocM`'ile, sest &krita; dokumendid vajavad erilist kohtlemist. Õigupoolest pole sugugi halb mõte kontrollida, ega saatmise tulemus pole 0, sest kui see on nii, siis import ei õnnestu.

Kui me kutsume filtri välja graafilisest kasutajaliidesest, üritame saada vaate. Kui vaade on olemas, üritab teisendamiskood värskendada edenemisriba.

Filtril on meile failinimi meie sisendafaili jaoks.

`KisDoc` peab olema impordiks ette valmistatud. Teatud seadistused algväärtustatakse ja tagasivõtmine keelatakse. Vastasel juhul saaks tagasi võtta kihtide lisamise, mida teeb importfilter, ja see annaks väga veidraid tulemusi.

Otsustasin teostada tegeliku importkoodi eraldi klassis, mille algväärtustan siin. Kogu koodi võib ka sellesse meetodisse asetada, aga see võib minna veidi segaseks.

Importija tagastab olekukoodi, millega saab määrata importfiltri oleku. Veateadete näitamise eest kannab hoolt &koffice;.

Kui `KisImage` loomine õnnestus, määrame dokumendi aktiivse pildi oma uueks pildiks. Seejärel ongi kõik: `return KoFilter::OK;`.