# Desenvolupant endollables per al &krita;

## Introducció

El &krita; és infinitament extensible amb endollables. Les eines, els filtres, grans troços de la interfície d'usuari i fins i tot espais de color són endollables. De fet, el &krita; reconeix aquestes sis tipus d'endollables:

- espais de color — defineixen els canals que constitueixen un únic píxel

- eines — qualsevol cosa que es faci amb un ratolí o dispositiu tauler d'introducció

- operations de dibuix — efectes endollables de dibuix per a eines

- filtres d'imatge — canvia tots els píxels, o només els seleccionats en una capa

- viewplugins — estén la interfície d'usuari del Krita amb noves caixes de diàleg, paletes i operacions

- filtres d'importació/exportació — llegeix i escriu tota mena de formats d'imatge

El &krita; mateix està composat per tres biblioteques en capes i un directori amb algunes classes comunes de suport: kritacolor, kritaimage i kritaui. Dins del &krita;, els objectes es poden identificar per un `KisID`, que és la combinació d'una única cadena no traduïda (usada quan es desa, per exemple) i una cadena traduïda per a la IGU.

Unes paraules sobre compatibilitat: el &krita; està encara en desenvolupament. Des del &krita; 1.5 a l'1.6 no s'esperen massa canvis a l'API, però potser n'hi ha alguna. Des del &krita; 1.6 al 2.0, hi haurà el canvi de les &Qt;3 a les &Qt;4, del &kde;3 al &kde;4, del `automake` al `cmake`: s'esperen molts canvis. Si desenvolupeu un endollable per al &krita; i escolliu fer-ho en la versió del repositori subversion del &krita;, hi ha grans possibilitats que us ajudem a portar-lo. Aquests canvis també portaran que parts d'aquest document esdevinguin obsoletes. Comproveu sempre l'última documentació de l'API o els fitxers de capçalera instal·lats al vostre sistema.

### KritaColor

La primera biblioteca és kritacolor. Aquest biblioteca carrega els endollables d'espai de color.

Un endollable d'espai de color hauria d'implementar la classe abstracta `KisColorSpace` o, si les capacitats bàsiques del nou espai de color s'implementaran per `lcms` (), exteneu `KisAbstractColorSpace`. La biblioteca kritacolor s'ha de poder usar des d'altres aplicacions i no depén del &koffice;.

### KritaImage

La biblioteca libkritaimage carrega els endollables de filtre i paintop i és el responsable de treballar amb dades d'imatge: canviant píxels, composant i pintang. Els pinzells, les paletes, els gradients i els patrons també els carrega la libkritaimage. El nostre objectiu definit és fer la libkritaimage independent del &koffice;, però actualment compartim el gradient carregant codi amb el &koffice;.

No és fàcil de moment afegir nous tipus de recursos com els pinzells, les paletes, els gradients o patrons al &krita;. (Afegir nous pinzells, paletes, gradients i patrons és fàcil, és clar.) El &krita; segueix les línies mestres del projecte Create () per a això. Afegir suport per al format de pinzell del Photoshop's necessita haquejar la libkritaimage; afegir més fitxers de dades de pinzell del Gimp, no.

`KritaImage` carrega els següents tipus d'endollables:

- Els filtres del &krita; s'han d'extendre i implementar les classes abstractes `KisFilter`, `KisFilterConfiguration` i possiblement `KisFilterConfigurationWidget`. Un exemple de filtre és Deforma màscara.

- Les operacions de dibuix o paintops són el conjunt d'operacions als què tenen accès les eines de dibuix com el de mà alçada o el cercle. Són exemples de paintops el lapis, l'aerosol o l'esborrador. Els paintops ha d'extendre la classe base `KisPaintop`. Exemples de nous paintops poden ser un pinzell pastel, un pinzell de pintura a l'oli o un pinzell programable complex.

### KritaUI

La biblioteca libkritaui carrega les eines i els endollables visualització. Aquesta biblioteca és part del &koffice;, però també conté un número d'estris útils per a aplicacions gràfiques. Potser haurem de dividir aquesta biblioteca en kritapart i kritaui a la versió 2.0. De moment, als escriptors d'scripts no se'ls dóna accés a aquesta biblioteca i els escriptors d'endollables només poden usar aquesta biblioteca quan escriuen eines o endollables de visualització. La `KritaUI` carrega els següents tipus d'endollables:

- Les eines es deriven de `KisTool` o una de les classes bàsiques d'eines especialitzades com a `KisToolPaint`, `KisToolNonPaint` o `KisToolFreehand`. Una nova eina pot ser una eina de selecció d'objecte de primer pla. Les eines de dibuix (i això inclou eines que dibuixen a la selecció) pot usar qualsevol paintop per a determinar la manera en què es canvien els píxels.

- Els endollables de visualització són KParts ordinàries que usen `kxmlgui` per a insinuar-se a la interfície d'usuari del &krita;. Les opcions de menú, els diàlegs, les barres d'eines — i qualsevol mena d'extensió d'interfície d'usuari pot ser un endollable de visualització. De fet, una important funcionalitat com el suport d'script del &krita; està escrita com a un endollable de visualització.

### Filtres d'Importació/Exportació

Els filtres d'Importació/Exportació són filtres del &koffice;, subclasses del `KoFilter`. Els filtres llegeixen i escriuen dades d'imatge en qualsevol de la miríada de formats d'imatges existents. Un exemple del nou filtre d'importació/exportació del &krita; pot ser un filtre PDF. Els filtres els carregen les biblioteques del &koffice;.

## Crea endollables

Els endollables s'escriuen en C++ i poden usar tots els API de desenvolupador del &kde;, les &Qt; i el &krita;. Només els endollables de visualització han d'usar l'API del &koffice;. No patiu: l'API del &krita; és prou clara i prou extensament documentada (per a programari lliure) i escriure el vostre primer filtre és fàcil de debò.

Si no voleu usar el C++, podeu escriure scripts en Python o Ruby; són coses diferents, però, i no podeu actualment escriure eines, espais de color, paintops o filtres d'importació/exportació com a scripts.

Els endollables del &krita; usen parts del mecanisme del &kde;'s per a carregar, de manera que la documentació de les parts, a , també és relevant en aquest cas.

La vostra distribució ha de tenir els fitxers de capçalera relevants instal·lats amb el &krita; mateix, o potser ha separat els fitxers de capçalera a un paquet &koffice; dev o &krita; dev. Podeu trobar la documentació de l'API per a l'API pública del &krita; a .

### Automake (i CMake)

El &kde; 3.x i per tant el &koffice; 1.5 i 1.6 usen `automake`; el &kde; 4.0 i el &koffice; 2.0 usen `cmake`. Aquest tutorial descriu la manera en què l'`automake` crea els endollables.

Els endollables són mòduls del &kde; i s'han d'etiquetar com a tals en el seu `Makefile.am`. Els filters, les eines, els paintops, els espais de color i els filtres d'importació/exportació necessiten fitxers `.desktop`; els endollables de visualització necessiten a més un fitxer KXMLGui `pluginname.rc`. La manera més fàcil de començar és donar un cop d'ull al projecte krita-plugins des del repositori de Subversion del &koffice; i usar-lo com a base per al vostre propi projecte. Volem preparar un paquet d'endollables bàsic del &krita; per al KDevelop, però no hem tingut temps encara per a fer-ho.

#### `Makefile.am`

Anem a mirar l'esquelet d'un mòdul d'endollable. Primer, el `Makefile.am`. Això és el que el &kde; usa per a generar el makefile que construeix el vostre endollable:

    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

Aquest és el makefile per a un endollable de filtre. Reemplaceu `LIBRARYNAME` pel nom de la vostra feina, i ja estareu.

Si el vostre endollable és de visualització, haureu d'instal·lar també un fitxer `.rc` amb entrades per a barres de menú i barres d'eines. De la mateixa manera, us caldrà instal·lar cursors i icones. Això es fa mitjançant els encanteris del `Makefile.am` ordinaris del &kde;:

    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

#### Fitxers Desktop

El fitxer `.desktop` anuncia el tipus d'endollable:

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

Possibles tipus de servei són:

- Krita/Filter

- Krita/Paintop

- Krita/ViewPlugin

- Krita/Tool

- Krita/ColorSpace

Els filtres d'importació i exportació de fitxer usen el marx de filtres genèric del &koffice; i cal que en parlem per separat.

#### Boilerplate

També us caldrà una mica de codi de boilerplate cridat per la part del marc del &kde; per a provocar l'endollable —, un fitxer de capçalera i un fitxer d'implementació.

Un fitxer de capçalera:

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

I un fitxer d'implementació:

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

#### Registres

Les eines les carrega l'eina de registre i els registres mateixos amb l'eina de registre. Els endollables com les eines, els filtres i els paintops es carreguen només un cop: els endollables de visualització es carreguen per a cada visualització que es crea. Noteu que registrem factories, parlant genèricament. Per exemple, amb les eines, es crea una nova instància de cada eina per a cada punter (ratolí, estil, esborrador) per a pocs. I es crea un nou paintop cada cop que una eina rep un esdeveniment del ratolí.

Els filtres criden el registre de filtres:

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

Els paintops, el registre de paintops:

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

Coloreja el registre de l'espai de color (amb algunes complicacions):

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

Els endollables de visualització no s'han de registrar, i obtenen accès a un objecte `KisView`:

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

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

           m_view = (KisView*) parent;
       }

Recordeu que això vol dir que es crearà un endollable de visualització per a cada vista que crei l'usuari; dividir una vista vol dir carregar de nou tots els endollables.

#### Versions d'endollables

El &krita; 1.5 carrega els endollables amb `X-KDE-Version=2` al fitxer `.desktop`. Els endollables del &krita; 1.6 seran probablement binàriament incompatibles amb els de l'1.5 i necessitaran la versió número 3. Els endollables del &krita; 2.0 plugins necessitaran la versió número 3. Sí, això no és completament lògic.

## Espais de color

Els espais de color implementa la classe purament virtual `KisColorSpace`. Hi ha dos tipus d'espais de color: aquells que usen `lcms` per a transformacions entre espais de color, i aquells que són massa estranys per a que els gestioni `lcms`. Exemples dels primers són are cmyk, rgb, yuv. Un exemple de l'últim és l'aquarel·la o wet & sticky. Els espais de color que usen `lcms` poden ser derivat de `KisAbstractColorSpace`, o d'una de les classes base especialitzades per a un cert número de bits per canal.

Implementar un espai de color és prou fàcil. El principi general és que els espais de color treballen en un rang simple de bytes. La interpretació d'aquests bytes depén de l'espai de color. Per exemple, un píxel en 16-bit GrayA està composat de quatre bytes: dos per al valor de gris i dos per al valor alfa. Sou lliures d'usar una estructura per a treballar amb format de memòria d'un píxel a la vostra implementació d'espai de color, però aquesta representació no s'exporta. L'única manera en què la resta del &krita; pot saber quins canals i tipus de canals composen el vostre espai de color és mitjançant la classe `KisView`.

Els filtres i paintops fan ús del ric conjunt de mètodes oferts pel `KisColorSpace` per a fer la seva feina. En molts casos, la implementació per omissió en `KisAbstractColorSpace` funcionarà, però més lenta del què ho faria una implementació personalitzada en els vostre propi espai de color perquè `KisAbstractColorSpace` convertirà tots els píxels a 16-bit L*a*b i a l'inrevès.

### `KisChannelInfo`

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

Aquesta classe defineix els canals que fan un píxel en un espai de color particular. Un canal té les següents característiques importants:

- un nom per a mostrar-lo a la interfície d'usuari

- una posició: el byte on comencen els bytes que representen aquest canal al píxel.

- un tipus: color, alfa, substància o substrat. El color ñes un color pla, alfa és la transparència, substància és una representació de la quantitat de pigment o coses com aquestes, substracte és la representació del llenç. (Noteu que això es pot rearranjar en un moment.)

- un valor de tipus: byte, short, integer, float o un altre.

- mida: el múmero de bytes que agafa aquest canal

- color: una representació `QColor` d'aquest canal per a la visualització de la interfície de l'usuari, per exemple en histogrames.

- una abreviació per a usar-la a la IGU quan no hi ha molt d'espai

### `KisCompositeOp`

Com per al Porter-Duff original, hi ha moltes maneres de combinar píxels per a obtenir un nou color. La classe `KisCompositeOp` defineix la majoria d'ells: aquest arranjament no és fàcilment extensible excepte hackejant la biblioteca kritacolor.

Un endollable d'espai de color pot suportar qualsevol subconjunt d'aquestes possibles operacions de composició, però el conjunt sempre ha d'incloure "OVER" (el mateix que "NORMAL") i "COPY". La resta són més o menys opcionals, malgrat que com més és millor, és clar.

### `KisColorSpace`

Els mètodes a la classe pura virtual `KisColorSpace` es pot dividir en uns quants grups: conversió, identificació i manipulació.

Totes les classes han de ser capaces de convertir un píxel a 8 bit RGB (és a dir, un `QColor`), i preferiblement també a 16 bit L*a*b. Addicionalment, hi ha un mètode per a convertir a qualsevol espai de color des de l'actual espai de color.

Els espais de color es descriuen amb el vector `KisChannelInfo`, el número de canals, el número de bytes en un píxel, si dóna suport a imatges d'alt rang dinàmic i més.

La manipulació és per exemple la combinació de dos píxels en un nou píxel: bitBlt, obscuriment o convulció de píxels.

Si us plau, consulteu la documentació de l'API per a una descripció completa de tots els mètodes que necessiteu per a implementar-los en un espai de color.

`KisAbstractColorSpace` implementa molts dels mètodes virtuals de `KisColorSpace` usant funcions des de la biblioteca `lcms`. A sobre de `KisAbstractColorSpace` hi ha classes base d'espais de color per a espais de color de 8 i 16 bit enters i 16 i 32 bit float que defineixen les operacions comunes per a moure entre profunditats de bit.

## Filters

Els filtres són endollables que examinen els píxels d'una capa i en fa canvis. Malgrat que el &krita; usa un rerefons de memòria en mosaic per a emmagatzemar píxels, els escriptors de píxels no s'han de preocupar per això. Quan escriviu un endollable de filtre per a l'API imaging de &Java;, el Photoshop o el Gimp, heu d'anar amb compte amb les vores del mosaic i cobble del mosaic alhora: el &krita; amaga aquest detall d'implementació.

Noteu que és fàcil, teòricament, reemplaçar el rerefons d'emmagatzement de dades d'imatge en mosaic actual amb un altre, però els rerefons no són endollables reals de moment, per raons de representació.

El &krita; usa iteratrs per a llegir i escriure valors de píxel. Alternativament, podeu llegir un bloc de píxels en una memòria intermèdia, jugar amb ell i després escriure-hi com a un bloc. Però això no és necessàriament més eficient, pot ser finsi tot més lent que usar els iterators; pot ser només més convenient. Mireu la documentació de l'API.

Les imatges del &krita; es componen de capes, de les quals hi ha actualment quatre tipus: capes de dibuix, capes de grup, capes d'ajustament (que contenen un filtre que s'aplica dinàmicament a les capes per sota del seu ajustament de capa) i capes de part. Els filtres sempre operen en capes de dibuix de la classe `KisPaintDevice`. Un dispositiu de dibuix, al seu torn, dóna accès als píxels reals.

Els `PaintDevice`s passen generalment ajustats en punters compartits. Un punter compartit manté la traçabilitat dels llocs on s'usa el dispositiu de dibuix i esborra el dispositiu quan ja no s'usa enlloc. Reconeixereu la versió del punter compartit d'un dispositiu de dibuix pel seu sufix `SP`. Recordeu que mai heu d'esborrar explícitament un `KisPaintDeviceSP`.

Anem a examinar un filtre molt simple, un que inverteix cada píxel. El codi per a aquest filtre és al directori `koffice/krita/plugins/filters/example`. El mètode principal és

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

La funció passa dos dispositius de dibuix, un objecte de configuració (que no s'usa en aquest filtre simple) i un `rect`. El `rect` descriu l'àrea del dispositiu de dibuix on el filtre ha d'actuar. Aquesta àrea es descriu per números sencers, el que vol dir que no hi ha precisió sub-píxel.

El dispositiu de dibuix `src` és per a llegir-hi, el `dst` és per a escriure-hi. Aquests paràmetres poden apuntar al mateix dispositiu de dibuix, o ser dos diferents dispositius. (Nota: això pot canviar a un únic dispositiu de dibuix en el futur.)

Ara, anem a mirar el codi línia per línia:

    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
    }

- Això crea un iterator per a llegir els píxels existents. El Krita té tres tipus d'iterators: horitzontals, verticals i rectangulars. L'iterator rect agafa el camí més eficient per les dades de la imatge, però no garanteix res sobre la localització del següent píxel que retorna. Això vol dir que no podeu assegurar que el píxel que trobareu després sigui adjacent al píxel que teníeu. Els iterators de lína horitzontal i vertical sí que garanteixen la localització dels píxels que retornen.

- (2) Creem l'iterator de destí amb l'arranjament `write` en `true`. Això vol dir que si el dispositiu de dibuix de destí és més petit que el rect que escrivim, s'engrandirà automàticament per a encaixar cada píxel on hi iteratem. Noteu que aquí hi ha un bug potencial: si `dst` i `src` no són el mateix dispositiu, llavors és molt possible que els píxels que retornin els iterators no corresponguin. Per a cada posició a l'iterator, `src` pot ser, per exemple, a 165,200, ,mentre que `dst` pot ser a 20,8 — i per tant la còpia que presentem a sota pot estar distorsionant la imatge...

- Voleu saber si un píxel està seleccionat? Això és fàcil usant el mètode `isSelected`. Però selectedness no és una propietat binària d'un píxel, un píxel pot estar mig seleccionat, poc seleccionat o quasi completament seleccionada. Aquest valor també el podeu obtenir des de l'iterator. Les seleccions són de fet un dispositiu de dibuix de màscara amb un rang d'entre 0 i 255, on 0 és completament deseleccionat i 255 completament seleccionat. L'iterator té dos mètodes: `isSelected()` i `selectedNess()`. Els primer retorna true si hi ha un píxel seleccionat en qualsevol extensió (és a dir, els valor de màscara és més gran que 1), l'altre returna el valor de màscara.

- Com es fa notat amunt, aquest `memcpy` és un gran bug... `rawData()` retorna la matriu de bytes que és l'estat actual del píxel; `oldRawData()` retorna la matriu de bytes com era abans de crear l'iterator. En canvi, podem copiar aquí el píxel dolent. A la pràctica, això no passarà sovint, a no ser que el `dst` ja existeixi i no està aliniat amb el `src`.

- Però això és correcte: per comptes d'esbrinar quin byte representa cada canal, usem una funció subministrada per tots els espais de color per a invertir el píxel actual. Els espais de color tenen un munt d'operacions de píxel que poseu usar.

Això no és tot per a crear un filtre. Els filtres tenen dos altres components importants: un objecte de configuració i un estri de configuració. Els dos interactuen de costat. L'estri de configuració crea un objecte de configuració, però també s'omplirà des d'un objecte de configuració preexistent. Els objectes de configuració es poden representar com a XML i es poden crear des d'un XML. Això és el que fa possible l'ajustament de les capes.

### Iterators

Hi ha tres tipus d'iterators:

- Línies horitzontals

- Línies verticals

- Iterors rectangulars

Els iteratos de línia horitzontal i vertical tenen un mètode per a moure l'iterator a la següent fila o columna: `nextRow()` i `nextCol()`. Usar-la és molt més ràpid que crear un nou iterator per a cada línia o columna.

Els iterators són segurs per als fils en el &krita;, de manera que és possible dividir la feina en múltiples fils. En canvi, futures versions del &krita; usarà el mètode `supportsThreading()` per a determinar si el vostre filtre es pot aplicar els troços de la imatge (és a dir, tots els píxels modificats independentment, per comptes de canviats per algun valor determinat des d'un examen de tots els píxels de la imatge) i automàticament enfila l'execució del vostre filtre.

### `KisFilterConfiguration`

`KisFilterConfiguration` és una estructura que s'usa per a desar els arranjaments de filtres al disc, per exemple per a capes d'ajustament. L'endollable d'scripting usa el mapa de propietat que hi ha darrera del `KisFilterConfigaration` per a fer possibles els filtres d'script. Els filtres poden subministrar un estri personalitzat que el &krita; mostrarà a la galeria de filtres, el diàleg de previsualització de filtres o la pestanya d'opció d'eina de l'eina paint-with-filters.

Un exemple, agafat del filtre d'efecte pintura a l'oli:

    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`

La majoria de filtres es poden pessigar. Podeu crear un estri de configuracií que el Krita usarà on sigui que useu el filtre. Un exemple:

El diàleg Pintura a l'oli El diàleg Pintura a l'oli

El diàleg Pintura a l'oli

Noteu que només la part esquerra d'aquest diàleg és de la vostra responsabilitat: el &krita; té cura de la resta. Hi ha tres maneres de fer per a crear un estri d'opció:

- Useu el &Qt; Designer per a crear una base d'estri, i feu-hi una subclasse per al vostre filtre

- Useu un dels estris simples que mostren un número de barres de desplaçament per a sencers per a llistes de sencers, dobles o bools. Aquests són útils si, com a la pantallada de dalt, el vostre filtre es poden configurar amb un número de sencers, dobles o bools. Mireu l'API dox per a `KisMultiIntegerFilterWidget`, `KisMultiDoubleFilterWidget` i `KisMultiBoolFilterWidget`.

- Picar a mà un estri. Això no està recomenat, i si ho feu i voleu que el vostre filtre formi part de la versió oficial del &krita;, llavors us demanaré de reemplaçar-lo per un estri fet amb el &Qt; Designer.

El filtre pintura a l'oli usa l'estri multiintegral:

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

Podeu veure com funciona: ompliu un vector amb els vostres paràmetres sencers i creeu l'estri. El mètode `configuration()` inspecciona l'estri i crea l'objecte de configuració de filtre adequat, en aquest cas, és clar, `KisOilPaintFilterConfiguration`. El mètode `listOfExamplesConfiguration` (que s'ha de reanomenar en correcte anglès...) retorna una llista amb objectes de configuració d'exemple per al diàleg de la galeria de filtres.

### Conclusió de filtres

Hi ha més que codificar filtres interessants, és clar, però amb aquesta explicació, la documentació de l'API i l'accés al nostre codi font, hauríeu de ser capaços de començar. No dubteu a contactar els desenvolupador del &krita; per IRC o a la llista de correu.

## Eines

Les eines apareixen a la caixa d'eines del &krita;. Això vol dir que hi ha un espai limitat per a noves eines, així que penseu bé quan una operació no és prou per als vostres propòsits. Les eines poden usar el ratolí/tauler i el teclat de maneres complexes, que les operacions de dibuix no poden. Aquesta és la raó per la qual Duplica és una eina, però esprai és una operació de dibuix.

Aneu amb compte amb les dades estàtiques de la vostra eina: es crea una nova instància de la vostra eina per a cada dispositiu d'introducció: ratolí, stylus, esborrador, esprai i el que sigui. Les eines venen dividides en grups lògics:

- conforma eines de dibuix (cercle, rect)

- eines de dibuix a mà alçada (pinzell)

- Eines de transformació que desordenen la geometria de la capa

- eines d'ompliment (com omple galleda o gradient)

- eines de visualització (que no canvia els píxels, però altera la manera en què visualitzeu el llenç, com l'apropament/allunyament)

- eines de selecció (que canvien la màscara de selecció)

La interfície d'eina es descriu a la documentació de l'API per a `KisTool`. Hi ha tres subclasses: `KisToolPaint`, `KisToolNonPaint` i `KisToolShape` (que de fet és una subclasse de `KisToolPaint`) que s'especialitza `KisTool` per a tasques de dibuix (és a dir, canviar els píxels) , les tasques que no són de dibuix i les tasques de forma de dibuix.

Una eina té un estri d'opció, justament com els filtres. Actualment, els estris d'opció es mostren en una pestanya en una finestra flotant. Podem canviar a una banda sota el menú principal (que llavors reemplaça la barra d'eines) per al &krita; 2.0, però per ara, dissenyeu el vostre estri d'opció per a encaixar en una pestanya. Com sempre, és millor usar el &Qt; Designer per al disseny de l'estri d'opció.

Unbon exemple d'una eina és l'eina d'estrella:

    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

Com veieu, necessiteu dues imatges: una per al cursor i una per a la caixa d'eines. `tool_star.cc` és només el carregador d'endollable, similar al què hem vist més amunt. La qüestió real és en la implementació:

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

El constructor arranja el nom intern "que no es tradueix" i la crida superclasse arranja el nom visible. També carreguem la imatge de cursor i arranja un munt de variables.

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

El mètode `update()` es crida quan se selecciona l'eina. Això no és un mètode `KisTool`, sinó un mètode `KisCanvasObserver`. Es notifica als observadors de llenç quan hi ha algun canvi a la visualització, que pot ser útil per a les eines.

Els següents mètodes (`buttonPress`, `move` i `buttonRelease`) els crida el &krita; quan el dispositiu d'introducció (ratolí, stylus, esborrador, etc) es pressiona, es mou o es deixa anar. Noteu que també podeu obtenir esdeveniments de moviment si el botó del ratolí no està pressionat. Els esdeveniments no són els esdeveniments habituals de les &Qt;, sinó esdeveniments sintètics del &krita; perquè fem ús de trucs de baix nivell per a obtenir prou esdeveniments com per a dibuixar una línia clara. Per omissió, els kits d'eines com les &Qt; (i les GTK) deixen anar esdeveniments si estan massa ocupades per a manegar-los, i nosaltres els volem tots.

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

El mètode `draw()` és un mètode intern de `KisToolStar` i dibuixa la vora d'una estrella. Ho cridem amb el mètode `move()` per a donar retroalimentació a l'usuari de la mida i forma de la seva estrella. Noteu que usem l'operació `Qt::NotROP`, que vol dir que cridant `draw()` per segon cop amb el mateix començament i el punt final, s'esborrarà l'estrella dibuixada prèviament.

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

El mètode `setup()` és essencial: aquí creem l'acció que s'endollarà a la caixa d'eines per tal que els usuaris puguin seleccionar de fet l'eina. També assignem una tecla de drecera. Noteu que hi ha alguna codificació en marxa: recordeu que creem una instància de l'eina per a cada dispositiu d'entrada. Això també vol dir que cridem `setup()` per a cada dispositiu d'entrada i que vol dir que una acció amb el mateix nom s'afegeix moltes vegades a la col·lecció d'accions. Malgrat tot, tot sembla funcionar. Així que, per què preocupar-se?

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

El mètode `starCoordinates()` conté matemàtiques curioses, però no és massa interessant per a la discussió sobre com crear un endollable d'eines.

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

El mètode `createOptionWidget()` es crida per a crear l'estri d'opció que el &krita; mostrarà a l'eina. Ja que hi ha una eina per dispositiu d'entrada, l'estat d'una eina es pot mantenir a l'eina. Aquest mètode es crida només un cop: l'estri d'opció s'emmagatzema i es recupera el següent cop que l'eina s'activa.

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

### Conclussions d'eina

Les eines són endollables relativament simples de crear. Cal que combineu les intefiícies `KisTool` i `KisCanvasObserver` per tal que crei efectivament una eina.

## Operacions de dibuix

Els PaintOps són un dels tipus d'endollables més innovadors del Krita (juntament amb els d'espais de color). Una operació de dibuix defineis com les eies canvien els píxels que toquen. L'esprai, el lapis aliased o el pinzell de píxel antialiased: aquestes són totes operacions de dibuix. Però podeu (amb molta feina) crear un paintop que llegeixi les definicions de pinzell XML del Corel Painter i les usi per a determinar com s'ha fet un dibuix.

Les operacions de dibuix s'inicien quan una eina de dibuix rep un esdeveniment de `mouseDown` i s'esborren quan rep l'esdeveniment mouseUp. Entre els dos, el paintop pot mantenir la traça de posicions prèvies i altres dades, com els nivells de pressió si l'usuari fa servir un tauler.

L'operació bàsica d'una operació de dibuix és canviar píxels a la posició del cursor d'una eina de dibuix. Això es pot fer només un cop, o aquesta pot demanar de ser usada a intervals regulars, usant un temporitzador. La primera pot ser útil per a un dibuix de tipus llapis, la segona, és clar, per a un paintop de tipus esprai.

Els paintops poden tenir un petit estri de configuració que s'emplaça a la barra d'eines. Així, els estris de configuració dels paintops han de tenir format horitzontal d'estris que no siguin més alts que un botó de barra d'eines. Si no, el &krita; tindrà un aspecte molt estrany.

Anem a mirar un endollable simple de paintop, un que mostri una mica d'intel·ligència programàtica. Primer, al fitxer de capçalera, hi ha una factoria definida. Aquesta factoria crea un paintop quan l'eina activa en necessita un:

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

    };

La factoria també conté el `KisID` amb els noms privat i públic per al paintop (assegureu-vos que el vostre nom privat del paintop no col·lisiona amb un altre paintop!) i retornarà opcionalment un mapa de píxels. El &krita; pot llavors mostrar el mapa de píxels jnut amb el nom per a la identificació visual del vostre paintop. Per exemple, un paintop de ganivet de pintor tindria la imatge d'aquesta implementació.

La implementació d'un paintop és molt directa:

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

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

Els mètode `paintAt()` és realment on ha de ser, amb els paintops. Aquest mètode rep dos paràmetres: la posició actual (que és en flotants, no en píxels sencers) i un objecte `KisPaintInformation` que conté la pressió, x i y, i el vector de moviment, i potser en el futur s'extengui amb altres informacions.

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

       KisBrush *brush = m_painter->brush();

Un `KisBrush` és la representació d'un fitxer de pinzell del Gimp: això és, una màscara, ja sigui una màscara simple o una sèrie de màscares. De fet, no usem el pinzell aquí, excepte per a determinar el hotspot sota el cursor.

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

Nosaltres no canviem els píxels d'un dispositiu de dibuix directament: per comptes d'això, creeem un petit dispositiu de dibuix, un dab, i el composem al dispositiu de dibuix actual.

    m_painter->setPressure(info.pressure);

Com diuen els comentaris, el següent tros de codi fa alguna feina programàtica per a crear el dab real. En aquest cas, dibuixem un número de línies. Quan acabo amb aquest paintop, la llargada, la posició i el gruix de les línies dependrà de la pressió i de la càrrega de pintura, i haurem creat un pinzell a l'oli. Però no he tingut temps d'acabar-lo encara.

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

Finalment, hem construït el dab al dispositiu de dibuix original i hem dit al pintor que hem embrutat un petit rectangle al dispositiu de dibuix.

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

Això és tot: els paintops són fàcils i divertits!

## Endollables de visualització

Els endollables de visualització són els més estranys de tots:un endollable de visualització és una KPart ordinària que pot proveir una mica d'interfície d'usuari i alguna funcionalitat. Per exemple, la pestanya d'histograma és un endollable de visualització, així com el diàleg de rotació.

## Filtres d'Importació/Exportació

El &krita; treballa amb l'arquitectura ordinària de filtres de fitxer del &koffice;. Hi ha un tutorial, una mica antic, però encara útil, a: . És probablement millor cooperar amb l'equip &krita; quan es desenvolupin filtres de fitxer i fer el desenvolupament a l'arbre de filtres del &koffice;. Noteu que podeu provar els vostres filtres sense usar el &krita; només usant la utilitat `koconverter`.

Els filtres tenen dues cares: la importació i l'exportació. Normalment, hi ha dos endollables diferents que comparteixen codi.

Les entrades importats `Makefile.am` són:

    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

Ja construïu un filtre d'importació o un d'exportació, la vostra feina sempre acabarà implementant la següent funció:

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

Són els arranjaments als fitxers `.desktop` els que determinen de quina manera converteix un filtre:

Importa:

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

Exporta:

    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

I sí, el tipus mime escollit per a l'exemple és una pista. Si us plau, si us plau, implementeu un filtre xcf?

### Importa

El gran problema amb els filtres d'importació és, naturalment, que el vostre codi llegeixi les dades del disc. L'important per a cridar aquest codi és prou simple:

Nota: de debò que hem de trobar una manera de fer que el &krita; mantingui obert un fitxer i només llegeixei dades a mida que ho vagi necessitant, per comptes de copiar tots els continguts a la representació interna del dispositiu de dibuix. Però això voldria dir rerefons de gestió de dades que entenen els fitxers tiff i d'altres, i no estan actualment implementats. Seria ideal si alguns filtres de fitxer poguessin implementar una classe provisionalment anomenada `KisFileDataManager`, creés un objecte d'aquesta instància amb el fitxer actual i el passés a KisDoc. Però el &krita; manega l'emmagatzement per capa, no per document, de manera que això seria una bona feina per a fer.

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

- Això se suposa que és un filtre d'importació, així si no es crida per a covertir a una imatge &krita;, llavors hi ha alguna cosa malament.

- La cadena de filtres ja ens ha creat un document de sortida. Ens cal repartir-la a la `KisDocM`, perquè els documents del &krita; necessiten un tractament especial. De fet, no seria pas una mala idea mirar si el resultat del repartiment no és 0, perquè si és així, la importació fallarà.

- Si cridem aquest filtre des de l'IGU, intentem obtenir la vista. Si hi ha una vista, el codi de conversió pot intentar actualitzar la barra de progrés.

- El filtre ens dóna el nom de fitxer per al fitxer d'entrada.

- Cal preparar el `KisDoc` per a la importació. Certs arranjaments s'inicialitzen i desfés està inhabilitat. D'altra manera, podríeu desfer l'afegiment de capes que fa el filtre d'importació i seria un comportament estrany.

- He escollit d'implementar el codi mateix d'importació en una classe separada que inicio aquí. També podeu introduir el vostre codi directament d'aquesta manera, però seria una mica brut.

- El meu importador retorna un codi d'estaurs que puc usar per a arranjar l'estatus del filtre d'importació. El &koffice; té cura de mostrar els missatges d'error.

- Si ha tingut èxit la creació del `KisImage`, arrangem la imatge actual del document a la nostra imatge creada ara mateix. Llavos ja estem: `return KoFilter::OK;`.