&chalk; è infinitamente estensibile. Gli strumenti, i filtri, ampie parti dell'interfaccia utente e anche gli spazi di colori sono plugin. &chalk; 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 &chalk; stesso è costituito da tre librerie stratificate e una cartella con alcune classi comuni di supporto: chalkcolor, chalkimage e chalkui. All'interno di &chalk;, 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à: &chalk; è ancora in fase di sviluppo. Da &chalk; 1.5 a 1.6 non ci si attendono molti cambiamenti nell'API, ma potrebbe essercene qualcuno. Da &chalk; 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 &chalk; e scegli di farlo nel deposito Subversion di &chalk;, 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. La prima libreria è chalkcolor. 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 chalkcolor potrebbe essere usata da altre applicazioni e non dipende da &koffice;. La libreria chalkimage 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 libchalkimage. È nostro obiettivo dichiarato rendere libchalkimage 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 &chalk; (aggiungere nuovi pennelli, tavolozze, sfumature o motivi è invece ovviamente facile). &chalk; segue le linee guida del progetto Create (sito Web). Aggiungere il supporto per il formato dei pennelli di Photoshop richiede modifiche a libchalkimage; aggiungere nuovi file di dati per i pennelli di Gimp, no. ChalkImage carica i seguenti tipi di plugin: I filtri di &chalk; 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. La libreria libchalkui 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 chalkpart e chalkui 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. ChalkUI 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 &chalk;. 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 &chalk; sono scritte come plugin di vista. 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 &chalk; potrebbe essere un filtro PDF. I filtri vengono caricati dalle librerie di &koffice;. I plugin si scrivono in C++ e possono usare tutta l'API di &kde;, &Qt; e &chalk;. Solo i plugin di vista dovrebbero usare l'API di &koffice;. Non preoccuparti: le API di &chalk; 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 &chalk; 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 &chalk; stesso, o potrebbe averli divisi in un pacchetto per sviluppatori di &koffice; o &chalk;. Puoi trovare la documentazione dell'API pubblica di &chalk; a questo indirizzo. &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 chalk 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 &chalk; per KDevelop, ma non ne abbiamo ancora avuto il tempo. 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 = chalkLIBRARYNAME.desktop INCLUDES = $(all_includes) chalkLIBRARYNAME_la_SOURCES = sourcefile1.cpp sourcefile2.cpp kde_module_LTLIBRARIES = chalkLIBRARYNAME.la noinst_HEADERS = header1.h header2.h chalkLIBRARYNAME_la_LDFLAGS = $(all_libraries) -module $(KDE_PLUGIN) chalkLIBRARY_la_LIBADD = -lchalkcommon chalkextensioncolorsfilters_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;: chalkrcdir = $(kde_datadir)/chalk/chalkplugins chalkrc_DATA = LIBRARYNAME.rc EXTRA_DIST = $(chalkrc_DATA) chalkpics_DATA = \ bla.png \ bla_cursor.png chalkpicsdir = $(kde_datadir)/chalk/pics Il file .desktop dichiara il tipo di plugin: [Desktop Entry] Encoding=UTF-8 Icon= Name=User-visible Name ServiceTypes=Chalk/Filter Type=Service X-TDE-Library=chalkLIBRARYNAME X-TDE-Version=2 I tipi di servizio (ServiceTypes) possibili sono: Chalk/Filter Chalk/Paintop Chalk/ViewPlugin Chalk/Tool Chalk/ColorSpace I filtri di importazione ed esportazione usano l'infrastruttura di filtraggio generica di &koffice; e vanno discussi a parte. 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 <tdeparts/plugin.h> /** * Un modulo che fornisce uno strumento stella*/ class ToolStar : public KParts::Plugin { TQ_OBJECT public: ToolStar(TQObject *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( chalktoolstar, ToolStarFactory( "chalk" ) ) ToolStar::ToolStar(TQObject *parent, const char *name, const QStringList &) : KParts::Plugin(parent, name) { setInstance(ToolStarFactory::instance()); if ( parent->inherits("KisToolRegistry") ) { KisToolRegistry * r = dynamic_cast<KisToolRegistry*>( parent ); r -> add(new KisToolStarFactory()); } } ToolStar::~ToolStar() { } #include "tool_star.moc" 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","chalkplugins/shearimage.rc"), true); (void) new TDEAction(i18n("&Shear Image..."), 0, 0, this, TQ_SLOT(slotShearImage()), actionCollection(), "shearimage"); (void) new TDEAction(i18n("&Shear Layer..."), 0, 0, this, TQ_SLOT(slotShearLayer()), actionCollection(), "shearlayer"); m_view = (KisView*) parent; } 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. &chalk; 1.5 carica i plugin con l'impostazione X-TDE-Version=2 nel file .desktop. I file binari dei plugin di &chalk; 1.6 probabilmente saranno incompatibili con i plugin 1.5 e richiederanno il numero di versione 3. I plugin di &chalk; 2.0 richiederanno il numero di versione 3. Sì, effettivamente non è del tutto logico. 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 &chalk; 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. (http://websvn.kde.org/trunk/koffice/chalk/chalkcolor/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 TQColor di questo canale per la visualizzazione nell'interfaccia utente, per esempio con istogrammi. un'abbreviazione da usare nell'interfaccia quando non c'è molto spazio 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 chalkcolor. 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 è. 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 TQColor), 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. I filtri sono plugin che esaminano i pixel in un livello e ci effettuano modifiche. Sebbene &chalk; 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: &chalk; 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. &chalk; 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 &chalk; 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/chalk/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. &chalk; 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. 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 &chalk; sono a prova di thread, quindi è possibile dividere il lavoro in thread diversi. Tuttavia, le versioni future di &chalk; 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 è 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 &chalk; 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"); }; }; La maggior parte dei filtri può essere modificata dall'utente. Puoi creare un widget di configurazione che &chalk; 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à: &chalk; 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 &chalk;, 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(TQWidget* parent, KisPaintDeviceSP /*dev*/) { vKisIntegerWidgetParam param; param.push_back( KisIntegerWidgetParam( 1, 5, 1, i18n("Brush size"), "brushSize" ) ); param.push_back( KisIntegerWidgetParam( 10, 255, 30, i18n("Smooth"), "smooth" ) ); return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param ); } KisFilterConfiguration* KisOilPaintFilter::configuration(TQWidget* nwidget) { KisMultiIntegerFilterWidget* widget = (KisMultiIntegerFilterWidget*) nwidget; if( widget == 0 ) { return new KisOilPaintFilterConfiguration( 1, 30); } else { return new KisOilPaintFilterConfiguration( widget->valueAt( 0 ), widget->valueAt( 1 ) ); } } std::list<KisFilterConfiguration*> KisOilPaintFilter::listOfExamplesConfiguration(KisPaintDeviceSP ) { std::list<KisFilterConfiguration*> list; list.insert(list.begin(), new KisOilPaintFilterConfiguration( 1, 30)); return list; } 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. 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 &chalk; su IRC o sulla mailing list. Gli strumenti compaiono nella raccolta di strumenti di &chalk;. 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 &chalk; 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.cpp Makefile.am tool_star_cursor.png wdg_tool_star.ui kis_tool_star.h Makefile.in tool_star.h chalktoolstar.desktop tool_star.cpp tool_star.png Come vedi, hai bisogno di due immagini: una per il cursore e una per la raccolta degli strumenti. tool_star.cpp è 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 &chalk; 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 &chalk; 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() & TQt::AltButton) { KisPoint trans = event->pos() - m_dragEnd; m_dragStart += trans; m_dragEnd += trans; } else { m_dragEnd = event->pos(); } // draw new lines on canvas draw(m_dragStart, m_dragEnd); } } void KisToolStar::buttonRelease(KisButtonReleaseEvent *event) { if (!m_subject || !m_currentImage) return; if (m_dragging && event->button() == LeftButton) { // erase old lines on canvas draw(m_dragStart, m_dragEnd); m_dragging = false; if (m_dragStart == m_dragEnd) return; if (!m_currentImage) return; if (!m_currentImage->activeDevice()) return; KisPaintDeviceSP device = m_currentImage->activeDevice ();; KisPainter painter (device); if (m_currentImage->undo()) painter.beginTransaction (i18n("Star")); painter.setPaintColor(m_subject->fgColor()); painter.setBackgroundColor(m_subject->bgColor()); painter.setFillStyle(fillStyle()); painter.setBrush(m_subject->currentBrush()); painter.setPattern(m_subject->currentPattern()); painter.setOpacity(m_opacity); painter.setCompositeOp(m_compositeOp); KisPaintOp * op = KisPaintOpRegistry::instance()->paintOp(m_subject->currentPaintop(), m_subject->currentPaintopSettings(), &painter); painter.setPaintOp(op); // Painter takes ownership vKisPoint coord = starCoordinates(m_vertices, m_dragStart.x(), m_dragStart.y(), m_dragEnd.x(), m_dragEnd.y()); painter.paintPolygon(coord); device->setDirty( painter.dirtyRect() ); notifyModified(); if (m_currentImage->undo()) { m_currentImage->undoAdapter()->addCommand(painter.endTransaction()); } } } 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 TQt::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(TQt::SolidLine); KisPoint startPos; KisPoint endPos; startPos = controller->windowToView(start); endPos = controller->windowToView(end); p.setRasterOp(TQt::NotROP); vKisPoint points = starCoordinates(m_vertices, startPos.x(), startPos.y(), endPos.x(), endPos.y()); for (uint i = 0; i < points.count() - 1; i++) { p.drawLine(points[i].floorQPoint(), points[i + 1].floorQPoint()); } p.drawLine(points[points.count() - 1].floorQPoint(), points[0].floorQPoint()); p.end (); } 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. Assegniamo 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(TDEActionCollection *collection) { m_action = static_cast<TDERadioAction *>(collection->action(name())); if (m_action == 0) { TDEShortcut shortcut(TQt::Key_Plus); shortcut.append(TDEShortcut(TQt::Key_F9)); m_action = new TDERadioAction(i18n("&Star"), "tool_star", shortcut, this, TQ_SLOT(activate()), collection, name()); TQ_CHECK_PTR(m_action); m_action->setToolTip(i18n("Draw a star")); m_action->setExclusiveGroup("tools"); m_ownAction = true; } } 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 &chalk; 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. TQWidget* KisToolStar::createOptionWidget(TQWidget* parent) { TQWidget *widget = KisToolShape::createOptionWidget(parent); m_optWidget = new WdgToolStar(widget); TQ_CHECK_PTR(m_optWidget); m_optWidget->ratioSpinBox->setValue(m_innerOuterRatio); QGridLayout *optionLayout = new QGridLayout(widget, 1, 1); super::addOptionWidgetLayout(optionLayout); optionLayout->addWidget(m_optWidget, 0, 0); return widget; } Gli strumenti sono plugin relativamente facili da creare. Devi combinare le interfacce KisTool e KisCanvasObserver per creare uno strumento. Le operazioni di disegno sono uno dei tipi più innovativi di plugin di &chalk; (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 &chalk; 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 TQString 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. &chalk; 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"); TQ_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); TQ_CHECK_PTR(op); return op; } Tutto qui: le operazioni di disegno sono facili! 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. &chalk; 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 &chalk; se sviluppi filtri per file e fare lo sviluppo nell'albero dei filtri di &koffice;. Nota che puoi provare i tuoi filtri senza avviare &chalk; 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 = chalk_XXX_import.desktop chalk_XXX_export.desktop servicedir = $(kde_servicesdir) kdelnk_DATA = chalk_XXX.desktop kdelnkdir = $(kde_appsdir)/Office libchalkXXXimport_la_SOURCES = XXXimport.cpp libchalkXXXexport_la_SOURCES = XXXexport.cpp METASOURCES = AUTO 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-TDE-Export=application/x-chalk X-TDE-Import=image/x-xcf-gimp X-TDE-Weight=1 X-TDE-Library=libchalkXXXimport ServiceTypes=KOfficeFilter Esportazione: X-TDE-Export=image/x-xcf-gimp X-TDE-Import=application/x-chalk ServiceTypes=KOfficeFilter Type=Service X-TDE-Weight=1 X-TDE-Library=libchalkXXXexport Sì, il tipo MIME scelto per l'esempio è un suggerimento. Qualcuno potrebbe per cortesia implementare un filtro per XCF? 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 &chalk; 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ò &chalk; 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-chalk") return KoFilter::BadMimeType; KisDoc * doc = dynamic_cast<KisDoc*>(m_chain -> outputDocument()); KisView * view = static_cast<KisView*>(doc -> views().getFirst()); TQString filename = m_chain -> inputFile(); if (!doc) return KoFilter::CreationError; doc -> prepareForImport(); if (!filename.isEmpty()) { KURL url(filename); if (url.isEmpty()) return KoFilter::FileNotFound; KisImageXXXConverter ib(doc, doc -> undoAdapter()); if (view != 0) view -> canvasSubject() -> progressDisplay() -> setSubject(&ib, false, true); switch (ib.buildImage(url)) { case KisImageBuilder_RESULT_UNSUPPORTED: return KoFilter::NotImplemented; break; case KisImageBuilder_RESULT_INVALID_ARG: return KoFilter::BadMimeType; break; case KisImageBuilder_RESULT_NO_URI: case KisImageBuilder_RESULT_NOT_LOCAL: return KoFilter::FileNotFound; break; case KisImageBuilder_RESULT_BAD_FETCH: case KisImageBuilder_RESULT_EMPTY: return KoFilter::ParsingError; break; case KisImageBuilder_RESULT_FAILURE: return KoFilter::InternalError; break; case KisImageBuilder_RESULT_OK: doc -> setCurrentImage( ib.image()); return KoFilter::OK; default: break; } } return KoFilter::StorageCreationError; } Questo dovrebbe essere un filtro di importazione, perciò se non viene chiamato per convertire in un'immagine di &chalk;, c'è qualcosa che non va. La catena dei filtri ha già creato un documento di output. Dobbiamo passarlo a KisDocM, perché i documenti di &chalk; 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;.