# Sviluppare plugin per &krita;

## Introduzione

&krita; è infinitamente estensibile. Gli strumenti, i filtri, ampie parti dell'interfaccia utente e anche gli spazi di colori sono plugin. &krita; riconosce sei tipi di plugin:

- spazi di colori: questi definiscono i canali che costituiscono un pixel

- strumenti: qualsiasi cosa fatta con un mouse o una tavoletta grafica

- operazioni di disegno: effetti di disegno per gli strumenti

- filtri delle immagini: cambiano tutti i pixel, o solo i pixel selezionati di un livello

- plugin di visualizzazione: estendono l'interfaccia utente di — con nuove finestre, tavolozze e operazioni

- filtri di importazione o esportazione: leggono e scrivono tutti i tipi di formati di immagini

&krita; stesso è costituito da tre librerie stratificate e una cartella con alcune classi comuni di supporto: kritacolor, kritaimage e kritaui. All'interno di &krita;, gli oggetti possono essere identificati da un `KisID`, cioè una combinazione di una stringa univoca non tradotta (usata per esempio nei salvataggi) e una stringa tradotta per l'uso nell'interfaccia utente.

Due parole sulla compatibilità: &krita; è ancora in fase di sviluppo. Da &krita; 1.5 a 1.6 non ci si attendono molti cambiamenti nell'API, ma potrebbe essercene qualcuno. Da &krita; 1.6 a 2.0 ci sposteremo da &Qt;3 a &Qt;4, da &kde;3 a &kde;4, da `automake` a `cmake`: ci si attendono molti cambiamenti. Se sviluppi un plugin per &krita; e scegli di farlo nel deposito Subversion di &krita;, molto probabilmente ti aiuteremo nel trasferimento. Questi cambiamenti potrebbero rendere obsolete parti di questo documento. Controlla sempre l'ultima documentazione dell'API o i file di intestazione installati sul tuo sistema.

### KritaColor

La prima libreria è kritacolor. Questa libreria carica i plugin per gli spazi di colori.

Un plugin per spazi di colori dovrebbe implementare la classe astratta `KisColorSpace` o, se le capacità di base del nuovo spazio di colori saranno implementate con `lcms` (sito Web), estendere `KisAbstractColorSpace`. La libreria kritacolor potrebbe essere usata da altre applicazioni e non dipende da &koffice;.

### KritaImage

La libreria kritaimage carica i plugin di filtraggio e delle operazioni di disegno, ed è responsabile del lavoro con i dati delle immagini: cambio dei pixel, composizione e disegno. Anche i pennelli, tavolozze, sfumature e motivi sono caricati da libkritaimage. È nostro obiettivo dichiarato rendere libkritaimage indipendente da &koffice;, ma attualmente condividiamo il codice di caricamento delle sfumature con &koffice;.

Non è facile al momento aggiungere nuovi tipi di risorse come pennelli, tavolozze, sfumature o motivi a &krita; (aggiungere nuovi pennelli, tavolozze, sfumature o motivi è invece ovviamente facile). &krita; segue le linee guida del progetto Create (sito Web). Aggiungere il supporto per il formato dei pennelli di Photoshop richiede modifiche a libkritaimage; aggiungere nuovi file di dati per i pennelli di Gimp, no.

`KritaImage` carica i seguenti tipi di plugin:

- I filtri di &krita; devono estendere e implementare le classi astratte `KisFilter`, `KisFilterConfiguration` ed eventualmente `KisFilterConfigurationWidget`. Un esempio di filtro è la maschera di contrasto.

- Le operazioni di disegno sono l'insieme di operazioni che gli strumenti di disegno come la mano libera e il cerchio hanno a disposizione. Esempi di operazioni sono la penna, l'aerografo o la gomma. Le operazioni dovrebbero estendere la classe di base `KisPaintop`. Esempi di nuove operazioni potrebbero essere un gessetto, un pennello a olio, o un complesso pennello programmabile.

### KritaUI

La libreria libkritaui carica i plugin degli strumenti e di vista. Questa libreria è un componente di &koffice;, ma contiene anche un certo numero di widget utili alle applicazioni grafiche. Forse dovremo dividere questa libreria in kritapart e kritaui nel rilascio 2.0. Per ora, chi scrive script non ha accesso alla libreria e chi scrive plugin può usarla solo quando scrive plugin per strumenti o di vista. `KritaUI` carica i seguenti tipi di plugin:

- Gli strumenti derivati da `KisTool` o una delle classi di base degli strumenti specializzati come `KisToolPaint`, `KisToolNonPaint` o `KisToolFreehand`. Un nuovo strumento potrebbe essere uno strumento di selezione degli oggetti in primo piano. Gli strumenti di disegno (inclusi gli strumenti che disegnano sulla selezione) possono usare qualsiasi operazione di disegno per determinare in che modo vengono cambiati i pixel.

- I plugin di vista sono normali componenti KPart che usano `kxmlgui` per infilarsi nell'interfaccia utente di &krita;. Le opzioni dei menu, le finestre, le barre degli strumenti, insomma qualsiasi tipo di estensione all'interfaccia utente può essere un plugin di vista. In effetti, importanti funzionalità come il supporto per gli script di &krita; sono scritte come plugin di vista.

### Filtri di importazione ed esportazione

I filtri di importazione ed esportazione sono filtri di &koffice;, sottoclassi di `KoFilter`. I filtri leggono e scrivono i dati delle immagini in uno qualsiasi della miriade di formati di immagine esistenti. Un esempio di un nuovo filtro di importazione ed esportazione di &krita; potrebbe essere un filtro PDF. I filtri vengono caricati dalle librerie di &koffice;.

## Creare plugin

I plugin si scrivono in C++ e possono usare tutta l'API di &kde;, &Qt; e &krita;. Solo i plugin di vista dovrebbero usare l'API di &koffice;. Non preoccuparti: le API di &krita; sono piuttosto chiare e ben documentate (per essere software libero) e scrivere il tuo primo filtro è veramente facile.

Se non vuoi usare il C++, puoi scrivere degli script in Python o Ruby; questa è però tutta un'altra cosa, però, e al momento non puoi scrivere strumenti, spazi di colori, operazioni o filtri di importazione ed esportazione come script.

I plugin di &krita; usano i componenti di &kde; come meccanismi per il caricamento, perciò anche la documentazione dei componenti è importante qui.

La tua distribuzione dovrebbe avere installato i file di intestazione di rilievo con &krita; stesso, o potrebbe averli divisi in un pacchetto per sviluppatori di &koffice; o &krita;. Puoi trovare la documentazione dell'API pubblica di &krita; a questo indirizzo.

### Automake (e CMake)

&kde; 3.x e quindi &koffice; 1.5 e 1.6 usano `automake`; &kde; 4.0 e &koffice; 2.0 usano `cmake`. Questa esercitazione descrive come creare plugin con `automake`.

I plugin sono moduli di &kde; e dovrebbero essere segnalati come tali nei loro `Makefile.am`. I filtri, gli strumenti, le operazioni di disegno, gli spazi di colori e i filtri di importazione ed esportazione richiedono dei file `.desktop`; i plugin di vista richiedono inoltre un file KXMLGui dal nome `pluginname.rc`. Il modo più semplice di cominciare è scaricare il progetto plugin di krita dal deposito Subversion di &koffice; e usarlo come base per il proprio progetto. Abbiamo intenzione di preparare uno pacchetto di base per i plugin di &krita; per KDevelop, ma non ne abbiamo ancora avuto il tempo.

#### `Makefile.am`

Diamo un'occhiata allo schema di un modulo plugin. Per prima cosa, `Makefile.am`. Questo è il file che &kde; usa per generare il makefile che compila il plugin:

    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

Questo è il makefile per un plugin di filtro. Sostituisci LIBRARYNAME con il nome del tuo progetto, e sei a posto.

Se il tuo è un plugin di vista, dovrai probabilmente installare anche un file `.rc` con le voci per le barre dei menu e degli strumenti. Allo stesso modo, potresti dover installare cursori ed icone. Tutto questo si può fare attraverso le solite magie per `Makefile.am` di &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

#### File del desktop

Il file `.desktop` dichiara il tipo di plugin:

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

I tipi di servizio (ServiceTypes) possibili sono:

- Krita/Filter

- Krita/Paintop

- Krita/ViewPlugin

- Krita/Tool

- Krita/ColorSpace

I filtri di importazione ed esportazione usano l'infrastruttura di filtraggio generica di &koffice; e vanno discussi a parte.

#### Codice da riutilizzare

Hai anche bisogno di un po' di codice comune chiamato dall'infrastruttura dei componenti di &kde; per avviare il plugin: un file di intestazione e uno di implementazione.

Un file di intestazione:

    #ifndef TOOL_STAR_H_
    #define TOOL_STAR_H_

    #include <kparts/plugin.h>

    /**
    * Un modulo che fornisce uno strumento stella*/
    class ToolStar : public KParts::Plugin
    {
       Q_OBJECT
    public:
       ToolStar(QObject *parent, const char *name, const QStringList &);
       virtual ~ToolStar();

    };

    #endif // TOOL_STAR_H_

E un file di implementazione:

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

#### Registri

Gli strumenti sono caricati dal registro degli strumenti e si registrano con esso. I plugin come strumenti, filtri e operazioni di disegno vengono caricati una sola volta: i plugin di vista vengono caricati per ogni vista creata. Nota che generalmente noi registriamo delle fabbriche. Per esempio, con gli strumenti, si crea una nuova istanza di uno strumento per ogni puntatore (mouse, penna, gomma), e viene creata una nuova operazione di disegno ogni volta che uno strumento riceve un evento di mouse premuto.

I filtri chiamano il registro dei filtri:

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

Le operazioni di disegno il registro delle operazioni:

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

Gli spazi di colori il registro degli spazi di colori (con qualche complicazione):

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

I plugin di vista non devono registrarsi, e hanno accesso a un oggetto `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;
       }

Ricordati che questo vuol dire che un plugin di vista sarà creato per ogni vista creata dall'utente: dividere una vista significa ricaricare tutti i plugin.

#### Versioni dei plugin

&krita; 1.5 carica i plugin con l'impostazione `X-KDE-Version=2` nel file `.desktop`. I file binari dei plugin di &krita; 1.6 probabilmente saranno incompatibili con i plugin 1.5 e richiederanno il numero di versione 3. I plugin di &krita; 2.0 richiederanno il numero di versione 3. Sì, effettivamente non è del tutto logico.

## Spazi di colori

Gli spazi di colori implementano la classe puramente virtuale `KisColorSpace`. Ci sono due tipi di spazi di colori: quelli che possono usare `lcms` per le trasformazioni tra spazi di colori, e quelli troppo particolari per essere gestiti da `lcms`. Esempi del primo tipo sono CMYK, RGB, e YUV. Un esempio del secondo tipo sono i colori ad acqua. Gli spazi di colori che usano `lcms` possono essere derivati da `KisAbstractColorSpace`, o una delle classi di base specializzate per un certo numero di bit per canale.

Implementare uno spazio di colori è piuttosto facile. Il principio generale è che gli spazi di colori lavorano con un semplice array di byte. L'interpretazione di questi byte è lasciata allo spazio di colori. Per esempio, un pixel in grigio a 16 bit consiste di quattro byte: due byte per il valore del grigio e due per il valore alfa. Sei libero di usare una struttura per lavorare con lo schema di memorizzazione di un pixel nell'implementazione del tuo spazio di colori, ma la rappresentazione non viene esportata. L'unico modo in cui il resto di &krita; può capire di quali canali e di quale tipo consistano i pixel del tuo spazio di colori è attraverso la classe `KisChannelInfo`.

I filtri e le operazioni di disegno usano i molti metodi offerti da `KisColorSpace` per fare il loro lavoro. In molti casi, l'implementazione predefinita in `KisAbstractColorSpace` funzionerà, ma più lentamente di un'implementazione configurata per il tuo spazio di colori perché `KisAbstractColorSpace` convertirà tutti i pixel in L*a*b a 16 bit e viceversa.

### `KisChannelInfo`

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

Questa classe definisce i canali che costituiscono un singolo pixel in un certo spazio di colori. Un canale ha le seguenti importanti caratteristiche:

- un nome da visualizzare nell'interfaccia utente

- una posizione: il byte dove cominciano i byte che rappresentano questo canale nel pixel.

- un tipo: colore, alfa, sostanza o substrato. Il colore è il semplice colore, alfa è la trasparenza, la sostanza è una rappresentazione della quantità di pigmento o cose simili, il substrato è la rappresentazione della tela (nota che questo potrebbe essere rifattorizzato in men che non si dica).

- un tipo di valore: byte, corto, intero, a virgola mobile o altro.

- dimensione: il numero di byte presi da questo canale

- colore: una rappresentazione `QColor` di questo canale per la visualizzazione nell'interfaccia utente, per esempio con istogrammi.

- un'abbreviazione da usare nell'interfaccia quando non c'è molto spazio

### `KisCompositeOp`

Come riportato dall'articolo originale di Porter e Duff, ci sono molti modi di combinare i pixel per ottenere un nuovo colore. La classe `KisCompositeOp` definisce la maggior parte di questi: questo insieme non è facilmente estensibile se non modificando la libreria kritacolor.

Un plugin per spazi di colori può supportare qualsiasi sottoinsieme di queste possibili operazioni di composizione, ma l'insieme deve sempre includere "OVER" (lo stesso che "NORMAL") e "COPY". Il resto è più o meno opzionale, anche se ovviamente più ce n'è meglio è.

### `KisColorSpace`

I metodi nella classe puramente virtuale `KisColorSpace` possono essere divisi in un certo numero di gruppi: conversione, identificazione e manipolazione.

Tutte le classi devono poter convertire un pixel da e in RGB a 8 bit (per esempio, un `QColor`), e preferibilmente anche in e da L*a*b a 16 bit. Inoltre, c'è un metodo per convertire in qualsiasi spazio di colori da quello attuale.

Gli spazi di colori sono descritti dal vettore `KisChannelInfo`, il numero di canali, il numero di byte in un singolo pixel, se supporta le immagini ad alto raggio dinamico (High Dynamic Range, HDR) e altro.

La manipolazione è, per esempio, la combinazione di due pixel in uno nuovo: bitBlt, oscuramento o convoluzione dei pixel.

Consulta la documentazione dell'API per una descrizione completa di tutti i metodi che devi implementare in uno spazio di colori.

`KisAbstractColorSpace` implementa molti dei metodi virtuali di `KisColorSpace` usando funzioni della libreria `lcms`. Oltre a `KisAbstractColorSpace` ci sono classi di base per gli spazi di colori a 8 e 16 bit interi e 16 e 32 bit a virgola mobile che definiscono operazioni comuni per spostarsi tra profondità in bit.

## Filtri

I filtri sono plugin che esaminano i pixel in un livello e ci effettuano modifiche. Sebbene &krita; usi un'efficiente interfaccia a memoria affiancata per memorizzare i pixel, gli autori di filtri non devono preoccuparsi di ciò. Quando scrivi un plugin di filtraggio per l'API grafica di &Java;, Photoshop o Gimp, devi fare attenzione ai bordi dei riquadri e ritagliarli al posto giusto: &krita; nasconde questo dettaglio di implementazione.

Nota che è teoricamente facile sostituire l'attuale interfaccia di memorizzazione affiancata dei dati delle immagini con un'altra, ma quelle interfacce non sono al momento veri plugin, per motivi di prestazioni.

&krita; usa gli iteratori per leggere e scrivere i valori dei pixel. In alternativa, puoi leggere un blocco di pixel in memoria temporanea, lavorarci e riscriverlo in blocco. Però ciò non è necessariamente più efficiente, e potrebbe anche essere più lento che usare gli iteratori; potrebbe semplicemente essere più comodo. Vedi la documentazione dell'API.

Le immagini di &krita; sono composte di livelli, dei quali ci sono al momento quattro tipi: livelli di disegno, di gruppo, di regolazione (che contengono un filtro applicato dinamicamente ai livelli inferiori) e di parte. I filtri operano sempre nei livelli di disegno. Questi contengono dispositivi di disegno, della classe `KisPaintDevice`. Un dispositivo di disegno, a sua volta, permette l'accesso ai pixel.

I `PaintDevice` sono generalmente passati come puntatori condivisi. Un puntatore condiviso tiene conto dei posti in cui il dispositivo è attualmente in uso e lo elimina quando non viene più usato da nessuna parte. Riconosci la versione a puntatore condiviso di un dispositivo di disegno dal su suffisso `SP`. Ricordati solo che non devi mai eliminare esplicitamente un `KisPaintDeviceSP`.

Diamo un'occhiata a un semplicissimo filtro, uno che inverta ogni pixel. Il codice del filtro è nella cartella `koffice/krita/plugins/filters/example`. Il metodo principale è

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

La funzione riceve due dispositivi di disegno, un oggetto di configurazione (che non viene usato in questo semplice filtro) e un `rect`. Il `rect` descrive l'area del dispositivo di disegno su cui il filtro dovrebbe avere effetto. Quest'area è descritta da interi, vale a dire senza precisione sotto il livello dei pixel.

Il dispositivo di disegno `src` è per leggere, il dispositivo `dst` è per scrivere. Questi parametri potrebbero anche puntare allo stesso dispositivo di disegno, o a due diversi (nota: nel futuro potrebbe diventare in un solo dispositivo).

Adesso, diamo un'occhiata al codice una riga alla volta:

    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
    }

Questo crea un iteratore per leggere i pixel esistenti. &krita; ha tre tipi di iteratori: orizzontali, verticali e rettangolari. L'iteratore rettangolare prende il percorso più efficiente nei dati dell'immagine, ma non garantisce nulla sulla posizione del prossimo pixel restituito. Ciò vuol dire che non puoi essere sicuro che il prossimo pixel che recupererai sarà di fianco al pixel che hai appena ricevuto. Gli iteratori di linea orizzontale e verticale garantiscono la posizione dei pixel che restituiscono.

(2) Creiamo l'iteratore di destinazione con `write` impostato a `true`. Ciò vuol dire che se il dispositivo di disegno di destinazione è più piccolo del rettangolo che scriviamo, sarà automaticamente ingrandito per adattarsi a ogni pixel su cui iteriamo. Nota che qui abbiamo un errore potenziale: se `dst` e `src` non sono lo stesso dispositivo, è possibile che i pixel restituiti dagli iteratori non corrispondano. Per ogni posizione dell'iteratore, `src` potrebbe, per esempio, essere a 165200, mentre `dst` potrebbe essere a 208, e quindi la copia potrebbe distorcere l'immagine.

Se vuoi sapere se un pixel è selezionato, usa il metodo `isSelected`. Però l'essere selezionato non è una proprietà binaria di un pixel, un pixel può essere selezionato a metà, appena o quasi del tutto. Puoi ottenere anche questo valore dall'iteratore. Le selezioni sono in realtà un dispositivo di disegno a maschera con un'intervallo tra 0 e 255, dove 0 è completamente non selezionato e 255 completamente selezionato. L'iteratore ha due metodi: `isSelected()` e `selectedNess()`. Il primo restituisce vero se un pixel è selezionato a qualsiasi livello (cioè se il valore della maschera è maggiore o uguale a 1), l'altro restituisce il valore della maschera.

Come notato sopra, questo `memcpy` può essere un brutto problema. `rawData()` restituisce l'array di byte che è lo stato attuale del pixel; `oldRawData()` lo restituisce come era prima che creassimo l'iteratore. Tuttavia, qui potremmo stare copiando il pixel sbagliato. In pratica, non capiterà spesso, a meno che `dst` esista già e non sia allineato a `src`.

Però è giusto: invece di cercare di capire quale canale rappresenta un byte, usiamo una funzione fornita da tutti gli spazi di colori per invertire il pixel attuale. Gli spazi di colori hanno molte operazioni sui pixel che puoi usare.

Questo non è tutto quello che c'è per la creazione dei filtri. I filtri hanno altre due componenti importanti: un oggetto e un widget di configurazione; i due interagiscono molto da vicino. Il widget di configurazione crea un oggetto di configurazione, ma può anche essere riempito con un oggetto di configurazione preesistente. Gli oggetti di configurazione possono rappresentarsi come XML ed essere creati da XML. Questo è quello che rende possibili i livelli di regolazione.

### Iteratori

Ci sono tre tipi di iteratori:

- Linee orizzontali

- Linee verticali

- Iteratori rettangolari

Gli iteratori a linea orizzontale e verticale hanno un metodo per spostare l'iteratore alla prossima riga o colonna: `nextRow()` e `nextCol()`. Usare questi è molto più veloce che creare un nuovo iteratore per ogni riga o colonna.

Gli iteratori di &krita; sono a prova di thread, quindi è possibile dividere il lavoro in thread diversi. Tuttavia, le versioni future di &krita; useranno il metodo `supportsThreading()` per determinare se il tuo filtro può essere applicato a pezzi dell'immagine (cioè se tutti i pixel possono essere modificati indipendentemente, invece che essere cambiati da qualche valore determinato da tutti i pixel dell'immagine) e eseguire automaticamente in thread il filtro.

### `KisFilterConfiguration`

`KisFilterConfiguration` è una struttura usata per salvare le impostazioni dei filtri sul disco, per esempio livelli di regolazione. Il plugin di scripting usa la mappa delle proprietà in fondo a `KisFilterConfigaration` per rendere possibile la scrittura di filtri con script. I filtri possono fornire un widget personalizzato che &krita; visualizzerà nella galleria dei filtri, nella finestra di anteprima dei filtri o la scheda delle opzioni degli strumenti dello strumento di disegno con filtri.

Un esempio, preso dal filtro dell'effetto di pittura a olio:

    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 maggior parte dei filtri può essere modificata dall'utente. Puoi creare un widget di configurazione che &krita; userà ovunque sia usato il filtro. Per esempio:

La finestra Pittura a olio La finestra Pittura a olio

La finestra Pittura a olio

Nota che solo il lato sinistro di questa finestra è tua responsabilità: &krita; fa il resto. Ci sono tre modi di creare un widget di opzioni:

- Usa &Qt; Designer per creare un widget di base, e fanne una sottoclasse per il tuo filtro

- Usa uno dei semplici widget che mostrano un certo numero di cursori per gli elenchi di numeri interi, a virgola mobile o valori booleani. Questi sono utili se, come nella schermata sopra, il filtro può essere configurato con un certo numero di cursori per gli elenchi di numeri interi, a virgola mobile o valori booleani. Vedi la documentazione dell'API di `KisMultiIntegerFilterWidget`, `KisMultiDoubleFilterWidget` e `KisMultiBoolFilterWidget`.

- Scrivi un widget a mano. Non è raccomandato, e se lo fai e vuoi che il tuo filtro diventi parte di un rilascio ufficiale di &krita;, ti chiederò di ripetere il tuo widget scritto a mano con un widget di &Qt; Designer.

Il filtro di pittura a olio usa il widget multiintero:

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

Puoi vedere come funziona: riempi un vettore con i tuoi parametri interi e crea il widget. Il metodo `configuration()` ispeziona il widget e crea il giusto oggetto di configurazione del filtro; in questo caso, ovviamente, `KisOilPaintFilterConfiguration`. Il metodo `listOfExamplesConfiguration` restituisce un elenco con oggetti di configurazione di esempio per la finestra della galleria dei filtri.

### Conclusione sui filtri

C'è ovviamente molto di più su come scrivere filtri interessanti, ma con queste spiegazioni, la documentazione dell'API e l'accesso al codice sorgente dovresti poter cominciare. Non esitare a contattare gli sviluppatori di &krita; su IRC o sulla mailing list.

## Strumenti

Gli strumenti compaiono nella raccolta di strumenti di &krita;. Ciò vuol dire che c'è un limite a quanti nuovi strumenti ci possono essere: ragiona piuttosto se un'operazione di disegno non potrebbe essere abbastanza per il tuo obiettivo. Gli strumenti possono usare il mouse (o la tavoletta) e la tastiera in modi complessi, cosa che le operazioni di disegno non possono fare. Questo è il motivo per cui Duplica è uno strumento, ma l'aerografo è un'operazione di disegno.

Fai attenzione ai dati statici nello strumento: viene creata una nuova istanza dello strumento per ogni dispositivo di input: mouse, pennino, gomma, aerografo, qualsiasi cosa. Gli strumenti vengono divisi in gruppi logici:

- strumenti per disegnare forme (cerchio, rettangolo)

- strumenti per disegnare a mano libera (pennello)

- strumenti di trasformazione che cambiano la geometria di un livello

- strumenti di riempimento (come il riempimento a secchio o le sfumature)

- strumenti di visualizzazione (che non cambiano nessun pixel, ma modificano il modo in cui vedi la tela, come l'ingrandimento)

- strumenti di selezione (che cambiano la maschera di selezione)

L'interfaccia degli strumenti è descritta nella documentazione dell'API di `KisTool`. Ci sono tre sottoclassi: `KisToolPaint`, `KisToolNonPaint` e `KisToolShape` (che in realtà è una sottoclasse di `KisToolPaint`) che specializzano `KisTool` per le operazioni di disegno (cioè cambiare i pixel), non di disegno e di disegno di forme.

Uno strumento ho un widget di opzioni, esattamente come i filtri. Attualmente, i widget di opzioni vengono visualizzati in una scheda in una finestra agganciata. Potremmo cambiarlo in una striscia sotto il menu principale (che sostituirebbe la barra degli strumenti) per &krita; 2.0, ma per ora progetta il widget di opzioni per stare nella scheda. Come sempre, è meglio usare &Qt; Designer per il widget di opzioni.

Un buon esempio di strumento è lo strumento Stella:

    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

Come vedi, hai bisogno di due immagini: una per il cursore e una per la raccolta degli strumenti. `tool_star.cc` è solo il programma che carica il plugin, un po' come abbiamo visto sopra. La parte importante è l'implementazione:

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

Il costruttore imposta il nome interno (che non va tradotto) e la chiamata alla classe superiore imposta il nome visibile. Carichiamo anche l'immagine del cursore e impostiamo un certo numero di variabili.

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

Il metodo `update()` viene chiamato quando lo strumento viene selezionato. Non è un metodo di `KisTool`, ma di `KisCanvasObserver`. Gli osservatori della tela ricevono un avviso ogni volta che qualcosa cambia nella visualizzazione, il che può essere utile per gli strumenti.

I seguenti metodi (`buttonPress`, `move` e `buttonRelease`) sono chiamati da &krita; quando il dispositivo di input (mouse, pennino, gomma, eccetera) viene premuto, spostato o rilasciato. Nota che avrai eventi di spostamento anche se il pulsante del mouse non viene premuto. Gli eventi non sono i normali eventi &Qt;, ma eventi sintetici di &krita; perché noi usiamo dei trucchetti di basso livello per avere abbastanza eventi da disegnare una linea liscia. Come impostazione predefinita, le librerie come &Qt; (e GTK) scartano gli eventi se hanno troppo da fare per gestirli, mentre noi invece li vogliamo tutti.

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

Il metodo `draw()` è un metodo interno di `KisToolStar` e disegna il profilo di una stella. Lo chiamiamo dal metodo `move()` per dare all'utente un'idea delle dimensioni e forma della stella. Nota che usiamo l'operazione raster `Qt::NotROP`, che vuol dire che se chiamiamo una seconda volta `draw()` con gli stessi punti iniziale e finale, la stella precedente sarà eliminata.

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

Il metodo `setup()` è essenziale: qui noi creiamo l'azione che sarà immessa nella raccolta degli strumenti in modo che gli utenti possano selezionare lo strumento. Assegnamo anche una chiave per la scorciatoia. Nota che abbiamo usato dei trucchi: ricorda che abbiamo creato un'istanza dello strumento per ogni dispositivo di input. Ciò vuol anche dire che chiamiamo `setup()` per ogni dispositivo di input e che un'azione con lo stesso nome viene aggiunta diverse volte alla raccolta di azioni. Però tutto sembra funzionare, e allora perché preoccuparsi?

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

Il metodo `starCoordinates()` contiene un po' di matematica strana, ma non è molto interessante per il discorso di come creare plugin strumenti.

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

Il metodo `createOptionWidget()` viene chiamato per creare il widget di opzioni che &krita; mostrerà nella scheda. Siccome c'è uno strumento per dispositivo di input per vista, lo stato di uno strumento può essere mantenuto nello strumento stesso. Questo metodo viene chiamato una sola volta: il widget di opzioni viene memorizzato e recuperato la prossima volta che lo strumento viene attivato.

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

### Conclusioni sugli strumenti

Gli strumenti sono plugin relativamente facili da creare. Devi combinare le interfacce `KisTool` e `KisCanvasObserver` per creare uno strumento.

## Operazioni di disegno

Le operazioni di disegno sono uno dei tipi più innovativi di plugin di &krita; (oltre agli spazi di colori). Un'operazione di disegno definisce come gli strumenti cambiano i pixel che toccano. L'aerografo, la matita e il pennello sono tutte operazioni. Però potresti (con molta fatica) creare un'operazione che legga le definizioni XML dei pennelli di Corel Painter e usi quelle per decidere come disegnare.

Le operazioni di disegno sono avviate quando uno strumento di disegno riceve un evento `mouseDown` e sono eliminate quando viene ricevuto un evento `mouseUp`. Nel frattempo, l'operazione può tenere a mente le posizioni precedenti e altri dati, come i livelli di pressione se l'utente usa una tavoletta.

Lo scopo fondamentale di un'operazione di disegno è cambiare i pixel alla posizione del cursore di uno strumento di disegno. Questo si può fare in una sola volta, oppure l'operazione può richiedere di essere eseguita a intervalli regolari, usando un timer. La prima possibilità sarebbe utile per un'operazione simile a una matita, la seconda per un aerografo.

Le operazioni di disegno possono avere un piccolo widget di configurazione che viene messo in una barra degli strumenti. Perciò i widget di configurazione delle operazioni devono avere una disposizione orizzontale di oggetti non più alti di un pulsante della barra. Altrimenti, l'aspetto di &krita; non sarà granché.

Diamo un'occhiata a un semplice plugin per un'operazione di disegno, uno che dia qualche segno di intelligenza programmatrice. Innanzi tutto, nel file di intestazione, è definita una fabbrica. Questa fabbrica crea un'operazione quando lo strumento attivo ne ha bisogno:

    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 fabbrica contiene anche l'identificativo `KisID` con i nomi pubblico e privato dell'operazione (assicurati che il nome privato dell'operazione non collida con un'altra) e potrebbe a scelta restituire un oggetto pixmap. &krita; potrà in questo caso mostrare il pixmap insieme al nome per l'identificazione visiva della tua operazione. Per esempio, un'operazione per il coltello da pittore avrebbe l'immagine di questo oggetto.

L'implementazione di un'operazione di disegno è molto semplice:

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

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

Il metodo `paintAt()` è la cosa più importante per le operazioni. Questo metodo riceve due parametri: la posizione attuale (in numeri a virgola mobile, non pixel interi) e un oggetto `KisPaintInformation` che contiene la pressione, l'inclinazione X e Y, il vettore di movimento e che in futuro potrebbe venire esteso con altre informazioni.

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

       KisBrush *brush = m_painter->brush();

Un `KisBrush` è la rappresentazione di un file di pennello di Gimp: cioè una maschera, sia una sola o una serie di maschere. In realtà noi non useremo il pennello qui, se non per determinare il punto calto sotto il cursore.

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

Non cambiamo direttamente i pixel di un dispositivo di disegno: invece, creiamo un piccolo dispositivo di disegno, una copia, e ricomporla sul dispositivo di disegno attuale.

    m_painter->setPressure(info.pressure);

Come dai commenti, la prossima sezione di codice fa del lavoro che serve a creare la copia. In questo caso, disegnamo un certo numero di linee. Quando questa operazione sarà finita, la lunghezza, posizione e spessore delle linee dipenderanno dalla pressione e dal carico di disegno, e avremo creato un pennello oleoso e pesante. Purtroppo non c'è ancora stato tempo per completarla.

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

Infine eseguiamo blt sulla copia per metterla sul dispositivo di disegno originale e dire al disegnatore che abbiamo sporcato un rettangolino del dispositivo.

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

Tutto qui: le operazioni di disegno sono facili!

## Plugin di vista

I plugin di vista sono i più strani del gruppo: un plugin di vista è un normale componente KPart che può fornice un po' di interfaccia utente e qualche funzionalità. Per esempio, la scheda degli istogrammi è un plugin di vista, come la finestra di rotazione.

## Filtri di importazione ed esportazione

&krita; funziona con l'architettura standard di filtraggio dei file di &koffice;. C'è un'esercitazione, un po' vecchia ma ancora utile, a questo indirizzo. Probabilmente è meglio lavorare con la squadra di &krita; se sviluppi filtri per file e fare lo sviluppo nell'albero dei filtri di &koffice;. Nota che puoi provare i tuoi filtri senza avviare &krita; usando il programma `koconverter`.

I filtri hanno due lati: importazione ed esportazione. Questi sono normalmente due plugin diversi che potrebbero condividere del codice.

Le voci importanti del file `Makefile.am` sono:

    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

Non importa se stai costruendo un filtro di importazione o di esportazione, il lavoro si riduce sempre a implementare questa funzione:

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

Sono le impostazioni nei file `.desktop` che determinano in che modo un filtro converte:

Importazione:

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

Esportazione:

    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

Sì, il tipo MIME scelto per l'esempio è un suggerimento. Qualcuno potrebbe per cortesia implementare un filtro per XCF?

### Importazione

Il problema principale con i filtri di importazione è ovviamente far leggere al tuo codice i dati del disco. Il codice riutilizzabile per chiamarlo è abbastanza semplice:

Nota: dovremmo davvero trovare un modo di permettere a &krita; di mantenere aperto un file e leggere i dati solo quando servono, invece che copiare tutti i contenuti nella rappresentazione grafica interna. Però questo vorrebbe dire avere delle interfacce di gestione dei dati che comprendono i file TIFF e tutto il resto, e questo al momento non è implementato. L'ideale sarebbe se alcuni filtri potessero implementare una classe temporaneamente battezzata `KisFileDataManager`, creare un oggetto di quell'istanza con il file attuale e passare a `KisDoc`. Però &krita; gestisce la memorizzazione in base ai livelli, non ai documenti, quindi sarebbe difficile da riorganizzare.

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

Questo dovrebbe essere un filtro di importazione, perciò se non viene chiamato per convertire in un'immagine di &krita;, c'è qualcosa che non va.

La catena dei filtri ha già creato un documento di output. Dobbiamo passarlo a `KisDocM`, perché i documenti di &krita; hanno bisogno di un trattamento speciale. In realtà non sarebbe una cattiva idea controllare che il risultato della chiamata non sia zero, perché in tal caso l'importazione non riuscirà.

Se chiamiamo questo filtro dall'interfaccia, proviamo a ottenere la vista. Se la vista c'è, il codice di conversione può provare ad aggiornare la barra di avanzamento.

Il filtro ha il nome del nostro file di input.

`KisDoc` deve essere preparato per un'importazione. Certe impostazioni sono inizializzate e l'annullamento delle azioni viene disattivato, altrimenti potresti annullare l'aggiunta di livelli effettuata dal filtro di importazione, e quello sarebbe un comportamento indesiderato.

Si è scelto di implementare il codice di importazione in una classe a parte che viene istanziata qui. Puoi anche mettere tutto il codice nel metodo, ma sarebbe un po' disordinato.

L'importatore restituisce un codice di stato che posso usare per impostare lo stato del filtro di importazione. &koffice; pensa a mostrare i messaggi di errore.

Se la creazione di `KisImage` è riuscita, impostiamo l'immagine attuale del documento alla nostra immagine appena creata. A questo punto abbiamo finito: `return KoFilter::OK;`.