&chalk; kan utökas i det oändliga med insticksprogram. Verktyg, filter, stora delar av användargränssnittet och alla färgrymder är insticksprogram. I själva verket känner &chalk; igen följande sex typer av insticksprogram: färgrymder — de definierar kanalerna som utgör en enstaka bildpunkt verktyg — allt som utförs med en mus eller styrplatta ritoperationer — riteffekter för verktyg som kan laddas bildfilter — ändra alla bildpunkter, eller bara markerade bildpunkter i ett lager vyinsticksprogram — utökar Chalks användargränssnitt med nya dialogrutor, paletter och åtgärder import- och exportfilter — läs och skriv alla sorters bildformat Själva &chalk; består av tre bibliotek i lager och en katalog med vissa gemensamma stödklasser: chalkcolor, chalkimage och chalkui. Inne i &chalk; kan objekt identifieras av ett KisID, som är kombinationen av en unik oöversatt sträng (som till exempel används när något ska sparas) och en översatt sträng avsedd för det grafiska användargränssnittet. Ett ord om kompatibilitet: &chalk; är fortfarande under utveckling. Om du utvecklar ett insticksprogram för &chalk; och väljer att göra det i &chalk;s subversion-arkiv, finns det utmärkta möjligheter att vi hjälper dig med överföringen. Ändringarna kan också göra att vissa delar av det här dokumentet blir föråldrade. Kontrollera alltid den senaste dokumentationen av programmeringsgränssnittet eller deklarationsfilerna som är installerade på ditt system. Det första biblioteket är chalkcolor. Detta bibliotek laddar färgrymdsinsticksprogram. Ett färgrymdsinsticksprogram ska implementera den abstrakta klassen KisColorSpace, eller om de grundläggande funktionerna i den nya färgrymden kommer att implementeras av lcms (), utöka KisAbstractColorSpace. Biblioteket chalkcolor kan användas från andra program, och beror inte på &koffice;. Biblioteket libchalkimage laddar filter- och ritoperationsinsticksprogram, och är ansvarigt för att arbeta med bilddata: ändra bildpunkter, sammanfoga och måla. Penslar, paletter, toningar och mönster laddas också av libchalkimage. Det är ett uttalat mål att göra libchalkimage oberoende av &koffice;, men för närvarande delar vi koden för att ladda toningar med &koffice;. Det är för närvarande inte enkelt att lägga till nya typer av resurser såsom penslar, paletter, toningar eller mönster i &chalk;. (Att lägga till nya penslar, paletter, toningar och mönster är förstås enkelt.) &chalk; följer anvisningarna från projektet Create () för dessa. Att lägga till stöd för Photoshops penselfilformat kräver kodning i libchalkimage. Att lägga till fler penseldatafiler från Gimp kräver inte det. ChalkImage laddar följande insticksprogramtyper: Filter i &chalk; måste utöka och implementera den abstrakta klassen KisFilter, KisFilterConfiguration och möjligen KisFilterConfigurationWidget. Ett exempel på ett filter är Oskarp mask. Ritoperationer är den uppsättning av operationer som ritverktyg som frihand eller cirkel har tillgång till. Exempel på ritoperationer är penna, retuschspruta eller radergummi. Ritoperationer ska utöka basklassen KisPaintop. Exempel på nya ritoperationer skulle kunna vara en chalk, en pensel för oljemålning eller en komplex programmerbar pensel. Biblioteket libchalkui laddar verktygen och vyinsticksprogrammen. Biblioteket är ett &koffice;-delprogram, men innehåller också ett antal grafiska komponenter som är användbara i grafikprogram. Kanske måste biblioteket delas i chalkpart och chalkui för utgåva 2.0. För närvarande ges inte författare av skript tillgång till biblioteket och författare av insticksprogram tillåts bara använda biblioteket när verktyg och vyinsticksprogram skrivs. ChalkUI laddar följande insticksprogramtyper: Verktyg härleds från KisTool eller en av de specialiserade verktygsbasklasserna såsom KisToolPaint, KisToolNonPaint eller KisToolFreehand. Ett nytt verktyg kan vara ett verktyg för markering av förgrunden. Ritverktyg (och det omfattar verktyg som ritar på markeringen) kan använda vilken ritoperation som helst för att bestämma hur bildpunkter ändras. Vyinsticksprogram är vanliga KParts, som använder kxmlgui för att ta sig in i &chalk;s användargränssnitt. Menyalternativ, dialogrutor, verktygsrader — alla sorters utökningar av användargränssnittet kan vara vyinsticksprogram. I själva verket är viktiga funktioner, som &chalk;s stöd för skript, skrivna som vyinsticksprogram. Import- och exportfilter är &koffice;-filter, delklasser till KoFilter. Filter läser och skriver bilddata på något av den uppsjö av bildformat som existerar. Ett exempel på ett nytt import- och exportfiler för &chalk; skulle kunna vara ett PDF-filter. Filter laddas av &koffice;-biblioteken. Insticksprogram skrivs i C++ och kan använda hela programmeringsgränssnittet i &tde; och &TQt; samt &chalk;s utvecklingsgränssnitt. Bara vyinsticksprogram ska använda &koffice; programmeringsgränssnittet. Oroa dig inte, &chalk;s programmeringsgränssnitt är mycket rent och relativt utförligt dokumenterat (för att vara fri programvara) och att koda ditt första filter är mycket enkelt. Om du inte vill använda C++ kan du skriva skript i Python eller Ruby: det är dock en helt annan sak, och du kan för närvarande inte skriva verktyg, färgrymder, ritoperationer eller import- och exportfilter som skript. Insticksprogram i &chalk; använder &kde;:s mekanism för delprogram vid laddning, så dokumentationen om delprogram på är också relevant här. Relevanta deklarationsfiler ska antingen ha installerats med själva &chalk; av din distribution, eller så har kanske deklarationsfilerna antingen lagts i paketet &koffice;-dev eller i &chalk;-dev. Du hittar dokumentationen av &chalk;s externa programmeringsgränssnitt på . &kde; 3.x och sålunda &koffice; 1.5 och 1.6 använder automake. &kde; 4.0 och &koffice; 2.0 använder cmake. Den här handledningen beskriver sättet att skapa insticksprogram som använder automake. Insticksprogram är &kde;-moduler, och ska markeras som sådana i Makefile.am. Filter, verktyg, ritoperationer, färgrymder samt import- och exportfiler behöver .desktop-filer. Vyinsticksprogram behöver dessutom en KXMLGui insticksprogramnamn.rc-fil. Det enklaste sättet att komma igång är att checka ut projektet chalk-plugins från &koffice; Subversion-arkiv och använda det som bas för ditt eget projekt. Vi har för avsikt att skapa ett paket med en &chalk; insticksprogrammall för Kdevelop, men har inte fått tid att göra det ännu. Låt oss ta en titt på mallen för en insticksmodul. Först filen Makefile.am. Den är vad &kde; använder för att skapa byggfilen som bygger insticksporgrammet: kde_services_DATA = chalkBIBLIOTEKSNAMN.desktop INCLUDES = $(all_includes) chalkBIBLIOTEKSNAMN_la_SOURCES = sourcefile1.cpp sourcefile2.cpp kde_module_LTLIBRARIES = chalkBIBLIOTEKSNAMN.la noinst_HEADERS = header1.h header2.h chalkBIBLIOTEKSNAMN_la_LDFLAGS = $(all_libraries) -module $(KDE_PLUGIN) chalkLIBRARY_la_LIBADD = -lchalkcommon chalkextensioncolorsfilters_la_METASOURCES = AUTO Detta är byggfilen för ett filterinsticksprogram. Ersätt BIBLIOTEKSNAMN med namnet på ditt arbete, så är du klar. Om ditt insticksprogram är ett vyinsticksprogram, installerar du troligen också en .rc-fil med poster för menyrader och verktygsrader. På liknande sätt kanske du också behöver installera markörer och ikoner. Allt detta görs via de magiska besvärjelserna i &kde;:s vanliga Makefile.am. chalkrcdir = $(kde_datadir)/chalk/chalkplugins chalkrc_DATA = BIBLIOTEKSNAMN.rc EXTRA_DIST = $(chalkrc_DATA) chalkpics_DATA = \ bla.png \ bla_cursor.png chalkpicsdir = $(kde_datadir)/chalk/pics Filen .desktop talar om insticksprogrammets typ: [Desktop Entry] Encoding=UTF-8 Icon= Name=User-visible Name ServiceTypes=Chalk/Filter Type=Service X-TDE-Library=chalkBIBLIOTEKSNAMN X-TDE-Version=2 Möjliga tjänsttyper är: Chalk/Filter Chalk/Paintop Chalk/ViewPlugin Chalk/Tool Chalk/ColorSpace Import- och exportfiler för filer använder det generella filterramverket i &koffice; och behöver beskrivas separat. Du behöver också en del standardkod som anropas av &kde;:s ramverk för delprogram för att instantiera insticksprogrammet — en deklarationsfil och en implementeringsfil. En deklarationsfil: #ifndef TOOL_STAR_H_ #define TOOL_STAR_H_ #include <tdeparts/plugin.h> /** * En modul som tillhandahåller ett stjärnverktyg. */ class ToolStar : public KParts::Plugin { TQ_OBJECT public: ToolStar(TQObject *parent, const char *name, const QStringList &); virtual ~ToolStar(); }; #endif // TOOL_STAR_H_ Och en implementeringsfil: #include <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" Verktyg laddas av verktygsregistret och registrerar sig själva med verktygsregistret. Insticksprogram som verktyg, filter och ritoperationer laddas bara en gång. Vyinsticksprogram laddas för varje vy som skapas. Observera att i allmänhet registrerar vi fabriker. För verktyg skapas exempelvis en ny instans av ett verktyg för varje pekare (mus, penna, radergummi), och en ny ritoperation skapas så fort ett verktyg får händelsen musklick. Filter anropar filterregistret: if (parent->inherits("KisFilterRegistry")) { KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent); manager->add(new KisFilterInvert()); } Ritoperationer ritoperationsregistret: if ( parent->inherits("KisPaintOpRegistry") ) { KisPaintOpRegistry * r = dynamic_cast<KisPaintOpRegistry*>(parent); r -> add ( new KisSmearyOpFactory ); } Färgrymder färgrymdsregistret (med vissa komplikationer): if ( parent->inherits("KisColorSpaceFactoryRegistry") ) { KisColorSpaceFactoryRegistry * f = dynamic_cast<isColorSpaceFactoryRegistry*>(parent); KisProfile *defProfile = new KisProfile(cmsCreate_sRGBProfile()); f->addProfile(defProfile); KisColorSpaceFactory * csFactory = new KisRgbColorSpaceFactory(); f->add(csFactory); KisColorSpace * colorSpaceRGBA = new KisRgbColorSpace(f, 0); KisHistogramProducerFactoryRegistry::instance() -> add( new KisBasicHistogramProducerFactory<KisBasicU8HistogramProducer> (KisID("RGB8HISTO", i18n("RGB8 Histogram")), colorSpaceRGBA) ); } vyinsticksprogram har inte något eget register, och de får tillgång till ett objekt av klassen KisView: if ( parent->inherits("KisView") ) { setInstance(ShearImageFactory::instance()); setXMLFile(locate("data","chalkplugins/shearimage.rc"), true); (void) new TDEAction(i18n("&Shear Image..."), 0, 0, this, TQ_SLOT(slotShearImage()), actionCollection(), "shearimage"); (void) new TDEAction(i18n("&Shear Layer..."), 0, 0, this, TQ_SLOT(slotShearLayer()), actionCollection(), "shearlayer"); m_view = (KisView*) parent; } Kom ihåg att detta betyder att ett vyinsticksprogram skapas för varje vy som användaren skapar: att dela en vy betyder att alla vyinsticksprogram laddas igen. &chalk; 1.5 laddar insticksprogram med X-TDE-Version=2 angivet i .desktop-filen. &chalk; 1.6 kommer troligen inte vara binärt kompatibla med 1.5 insticksprogram och kommer att behöva versionsnumret 3. &chalk; 2.0 insticksprogram kommer att behöva versionsnumret 3. Ja, det är inte helt logiskt. Färgrymder implementerar den rent virtuella klassen KisColorSpace. Det finns två typer av färgrymder: de som kan använda lcms för överföringar mellan färgrymder, och de som är för konstiga för lcms att hantera. Exempel på de första är cmyk, rgb, yuv. Ett exempel på den senare är watercolor eller wet & sticky. Färgrymder som använder lcms kan härledas från KisAbstractColorSpace eller en av basklasserna som är specialiserade för ett visst antal bitar per kanal. Det är ganska enkelt att implementera en färgrymd. Den allmänna principen är att färgrymder arbetar med ett enkelt fält av byte. Tolkningen av dessa bestäms av färgrymden själv. Till exempel består en bildpunkt i 16-bitars GrayA av fyra byte: två för gråskalevärdet och två för alfavärdet. Du är fri att använda en post för att arbeta med minneslayouten av en bildpunkt i din implementering av färgrymden, men den representationen exporteras inte. Det enda sättet som resten av &chalk; kan veta vilka kanaler och typer av kanaler din färgrymds bildpunkter består av är via klassen KisChannelInfo. Filter och ritoperationer utnyttjar den omfattande mängd metoder som tillhandahålls av KisColorSpace för att utföra sitt arbete. I många fall fungerar standardimplementeringen i KisAbstractColorSpace men långsammare än en egen implementering i din egen färgrymd, eftersom KisAbstractColorSpace konverterar alla bildpunkter till 16-bitars L*a*b och tillbaka. (http://websvn.kde.org/trunk/koffice/chalk/chalkcolor/kis_channelinfo.h) Den här klassen definierar kanalerna som utgör en ensam bildpunkt i en viss färgrymd. En kanal har följande viktiga egenskaper: ett namn på en skärm i användargränssnittet en position: den byte där alla de byte som representerar kanalen börjar i bildpunkten. en typ: färg, alfa, substans eller substrat. Färg är vanlig färg, alfa är genomskinlighet, substans är en representation av mängden pigment eller likande saker, substrat är en representation av duken. (Observera att det kan ändras om snabbt som ögat.) en värdetyp: byte, short, integer, float — eller något annat. storlek: antal byte som kanalen upptar färg: en representation med TQColor av kanalen för visualisering i användargränssnitt, till exempel i histogram. en förkortning att använda i det grafiska användargränssnittet när det inte finns mycket utrymme Liksom för den ursprungliga Porter-Duff, finns det många sätt att kombinera bildpunkter för att få en ny färg. Klassen KisCompositeOp definierar de flesta av dem: Uppsättningen kan inte enkelt utökas utom genom att ändra kod i biblioteket chalkcolor. Ett färgrymdsinsticksprogram kan stödja vilken delmängd av de möjliga sammansättningsoperationerna som helst, men uppsättningen måste alltid omfatta "OVER" (samma som "NORMAL") och "COPY". De övriga är mer eller mindre valfria, även om fler naturligtvis är bättre. Metoderna i den rent virtuella klassen KisColorSpace kan delas upp i ett antal grupper: konvertering, identifikation och behandling. Alla klasser måste kunna konvertera en bildpunkt från och till 8-bitars RGB (dvs. en TQColor), och helst också till och från 16-bitars L*a*b*. Dessutom finns en metod för att konvertera till vilken annan färgrymd som helst från den nuvarande färgrymden. Färgrymder beskrivs av vektorn KisChannelInfo, antal kanaler, antal byte i en enda bildpunkt, om den stöder bilder med stort dynamiskt område, med mera. Behandling är till exempel att kombinera två bildpunkter till en ny bildpunkt: bitBlt, att göra bildpunkter mörkare eller faltning av bildpunkter. Titta i dokumentationen av programmeringsgränssnittet för en fullständig beskrivning av alla metoder du måste implementera i en färgrymd. KisAbstractColorSpace implementerar många av de virtuella metoderna i KisColorSpace med användning av funktioner från biblioteket lcms. Ovanpå KisAbstractColorSpace finns det basklasser för färgrymder med 8- och 16-bitars heltal samt 16- och 32-bitars flyttal som definierar gemensamma operationer för att gå mellan bitdjup. Filter är insticksprogram som undersöker bildpunkter i ett lager och därefter utför ändringar av dem. Även om &chalk; använder ett effektiv minnesgränssnitt baserat på plattor för att lagra bildpunkter, behöver upphovsmän till filter inte bekymra sig om det. När ett filterinsticksprogram skrivs för bildbehandlingsgränssnittet i &Java;, Photoshop eller Gimp måste man ta hand om plattornas kanter och passa ihop plattor med varandra. &chalk; döljer alla sådana implementeringsdetaljer. Observera att det teoretiskt är enkelt att ersätta det nuvarande gränssnittet för datalagring baserat på plattor med ett annat gränssnitt, men att gränssnitten av prestandaskäl för närvarande inte är riktiga insticksprogram. &chalk; använder interation för att läsa och skriva bildpunktsvärden. Som ett alternativ kan du läsa in ett block med bildpunkter i en minnesbuffer, greja med det och därefter skriva tillbaka det som ett block. Det är dock inte nödvändigtvis effektivare, utan kan till och med vara långsammare än att använda iteration: det kanske bara är bekvämare. Se dokumentationen av programmeringsgränssnittet. Bilder i &chalk; består av lager, varav det för närvarande finns fyra sorter: ritlager, grupplager, justeringslager (som innehåller ett filter som dynamiskt används för lager under justeringslagret) och delprogramlager. Filter arbetar alltid med ritlager. Ritlager innehåller uppritningsenheter av klassen KisPaintDevice. En uppritningsenhet ger i sin tur möjlihet att komma åt själva bildpunkterna. En PaintDevice skickas i allmänhet omkring inbäddad i en delad pekare. En delat pekare håller ordning på hur många ställen som uppritningsenheten för närvarande används, och tar bort uppritningsenheten när den inte längre används någonstans. Du känner igen versionen av en uppritningsenhet med en delad pekare på dess suffix SP. Kom bara ihåg att du aldrig explicit behöver ta bort en KisPaintDeviceSP. Låt oss undersöka ett mycket enkelt filter, ett som inverterar alla bildpunkter. Koden för filtret finns i katalogen koffice/chalk/plugins/filters/example. Huvudmetoden är: KisFilterInvert::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration* /*config*/, const QRect& rect). Funktionen tar emot två uppritningsenheter, ett inställningsobjekt (som inte används i det här enkla filtret) och en rect. Denna rect beskriver uppritningsenhetens område som filtret ska hantera. Området beskrivs med heltal, vilket betyder att det inte finns någon noggrannhet på delbildpunktsnivå. Uppritningsenheten src är till för att läsa från, och uppritningsenheten dst är till för att skriva till. Parametrarna kan peka på samma verkliga uppritningsenhet, eller vara två olika uppritningsenheter. (Observera: detta kan ändras till en enda uppritningsenhet i framtiden.) Låt oss nu betrakta koden rad för rad: void KisFilterInvert::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration* /*config*/, const QRect& rect) { Q_ASSERT(src != 0); Q_ASSERT(dst != 0); KisRectIteratorPixel srcIt = src->createRectIterator(rect.x(), rect.y(), rect.width(), rect.height(), false); KisRectIteratorPixel dstIt = dst->createRectIterator(rect.x(), rect.y(), rect.width(), rect.height(), true ); int pixelsProcessed = 0; setProgressTotalSteps(rect.width() * rect.height()); KisColorSpace * cs = src->colorSpace(); Q_INT32 psize = cs->pixelSize(); while( ! srcIt.isDone() ) { if(srcIt.isSelected()) { memcpy(dstIt.rawData(), srcIt.oldRawData(), psize); cs->invertColor( dstIt.rawData(), 1); } setProgress(++pixelsProcessed); ++srcIt; ++dstIt; } setProgressDone(); // Måste anropas även om det inte stöds } Detta skapar en iteration för att läsa befintliga bildpunkter. Chalk har tre typer av iteration: horisontell, vertikal och rektangulär. Iterationen rect går det effektivaste vägen genom bilddata, men garanterar inte någonting om platsen för nästa bildpunkt den returnerar. Det betyder att du inte kan vara säker på att bildpunkten du hämtar nästa gång ligger intill bildpunkten du just tog emot. De horisontella och vertikala iterationerna garanterar verkligen platsen för bildpunkterna de returnerar. Vi skapar destinationsiterationen med värdet true för inställningen write. Det betyder att om destinationens uppritningsenhet är mindre än rektangeln vi skriver, förstoras den automatiskt för att omfatta alla bildpunkter i iterationen. Observera att vi har ett potentiellt fel här: om dst och src inte är samma enhet är det mycket möjligt att bildpunkterna som iterationerna returnerar inte motsvarar varandra. För varje position i iterationen kan src till exempel vara 165, 200, medan dst skulle kunna vara 20, 8 — och därför skulle kopian vi gör nedan kunna förvränga bilden ... Vill du veta om en bildpunkt är markerad? Det är enkelt: använd metoden isSelected. Men att vara markerad är inte en binär egenskap hos en bildpunkt. En bildpunkt kan vara halvmarkerad, nästan omarkerad, eller nästan helt markerad. Markeringar är i själva verket en maskuppritningsenhet med intervallet 0 till 255, där 0 är helt omarkerad och 255 helt markerad. Iterationen har två metoder: isSelected() and selectedNess(). Det första returnerar sant om en bildpunkt överhuvudtaget är markerad (dvs. maskvärdet är större än 1), den andra returnerar maskvärdet. Som nämndes ovan, är denna memcpy ett stort fult fel ... rawData() returnerar bytefältet som är bildpunktens nuvarande tillstånd och oldRawData() returnerar bytefältet som det var innan vi skapade iterationen. Vi kan dock kopiera fel bildpunkt här. I verklig användning händer inte det alltför ofta, om inte dst redan finns och inte är justerad i förhållande till src. Men det är riktigt: Istället för att räkna ut vilken byte som representerar vilken kanal, använder vi en funktion som tillhandahålls av alla färgrymder för att invertera den aktuella bildpunkten. Färgrymderna har en mängd bildpunktsoperationer som du kan utnyttja. Detta är inte allt som behövs för att skapa ett filter. Filter har två andra viktiga komponenter: ett inställningsobjekt och en grafisk inställningskomponent. De två fungerar tätt tillsammans. Den grafiska inställningskomponenten skapar ett inställningsobjekt, men kan också fyllas i från ett inställningsobjekt som redan existerar. Inställningsobjekt kan representeras som XML, och kan skapas från XML. Det är det som gör justeringslager möjliga. Det finns tre typer av iterationer: Horisontella linjer Vertikala linjer Rektangulära iterationer De horisontella och vertikala linjeiterationerna har en metod för att flytta iterationen till nästa rad eller kolumn: nextRow() och nextCol(). Att använda dem är mycket snabbare än att skapa en ny iteration för varje rad eller kolumn. Iterationer är trådsäkra i &chalk;, så det är möjligt att dela upp arbetet i flera trådar. Dock kommer framtida versioner av &chalk; att använda metoden supportsThreading() för att avgöra om filtret kan användas på stycken av bilden (dvs. alla bildpunkter ändrade oberoende av varandra, istället för ändrade av något värde som bestäms av att undersöka alla bildpunkter i bilden) och automatiskt använda trådar för att köra filtret. KisFilterConfiguration är en struktur som används för att spara filterinställningar på disk, till exempel för justeringslager. Skriptinsticksprogrammet använder egenskapsavbildningen som finns längst bak i KisFilterConfigaration för att göra det möjligt att göra skript med filter. Filter kan tillhandahålla en egen grafisk komponent som &chalk; visar i filtergalleriet, förhandsgranskningen av filter och fliken med verktygsalternativ för verktyget Rita med filter. Ett exempel, som kommer från filtret för oljemålningseffekt: class KisOilPaintFilterConfiguration : public KisFilterConfiguration { public: KisOilPaintFilterConfiguration(Q_UINT32 brushSize, Q_UINT32 smooth) : KisFilterConfiguration( "oilpaint", 1 ) { setProperty("brushSize", brushSize); setProperty("smooth", smooth); }; public: inline Q_UINT32 brushSize() { return getInt("brushSize"); }; inline Q_UINT32 smooth() {return getInt("smooth"); }; }; De flesta filter kan justeras av användaren. Du kan skapa en inställningskomponent som Chalk användaer så fort filtret används. Ett exempel: Dialogrutan Oljemålning Dialogrutan Oljemålning Dialogrutan Oljemålning Observera att bara vänstersidan av dialogrutan är ditt ansvar: &chalk; tar hand om resten. Det finns tre sätt att bete sig för att skapa en alternativkomponent: Använd &TQt; Designer för att skapa basen för den grafiska komponenten, och skapa en delklass för filtret Använd en av de enklaste grafiska komponenterna som visar ett antal skjutreglage för listor av heltal, flyttal med dubbel precision eller Booleska värden. Se dokumentationen av programmeringsgränssnittet för KisMultiIntegerFilterWidget, KisMultiDoubleFilterWidget och KisMultiBoolFilterWidget. Handkoda en grafisk komponent. Det rekommenderas inte, och om du gör det och vill att filtret ska vara en del av &chalk;s officiella utgåva, ber jag dig att ersätta din handkodade komponent med en &TQt; Designer-komponent. Oljemålningsfiltret använder flerheltalskomponenten: KisFilterConfigWidget * KisOilPaintFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP /*dev*/) { vKisIntegerWidgetParam param; param.push_back( KisIntegerWidgetParam( 1, 5, 1, i18n("Brush size"), "brushSize" ) ); param.push_back( KisIntegerWidgetParam( 10, 255, 30, i18n("Smooth"), "smooth" ) ); return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param ); } KisFilterConfiguration* KisOilPaintFilter::configuration(TQWidget* nwidget) { KisMultiIntegerFilterWidget* widget = (KisMultiIntegerFilterWidget*) nwidget; if( widget == 0 ) { return new KisOilPaintFilterConfiguration( 1, 30); } else { return new KisOilPaintFilterConfiguration( widget->valueAt( 0 ), widget->valueAt( 1 ) ); } } std::list<KisFilterConfiguration*> KisOilPaintFilter::listOfExamplesConfiguration(KisPaintDeviceSP ) { std::list<KisFilterConfiguration*> list; list.insert(list.begin(), new KisOilPaintFilterConfiguration( 1, 30)); return list; } Du ser hur det fungerar: Fyll i en vektor med heltalsparametrar och skapa den grafiska komponenten. Metoden configuration() inspekterar den grafiska komponenten och skapar det rätta filterinställningsobjektet, i detta fall förstås KisOilPaintFilterConfiguration. Metoden listOfExamplesConfiguration (som borde döpas om till riktig engelska ...) returnerar en lista med exempelinställningsobjekt för dialogrutan med filtergalleriet. Det krävs förstås mer för att koda intressanta filter, men med denna förklaring, dokumentationen av programmeringsgränssnittet och tillgång till vår källkod, bör du kunna komma igång. Tveka inte att kontakta utvecklarna av &chalk; på IRC eller via e-postlistan. Verktyg visas i &chalk;s verktygslåda. Det betyder att det finns begränsat utrymme för nya verktyg: tänk noga efter om en ritoperation inte är tillräckligt för ditt syfte. Verktyg kan använda musen eller styrplattan och tangentbordet på komplexa sätt, vilket ritoperationer inte kan. Det är orsaken till att Duplicera är ett verktyg, medan retuschsprutan är en ritoperation. Var försiktig med statisk data i verktyget: en ny instans av verktyget skapas för varje indataenhet: mus, penna, radergummi, retuschspruta med mera. Verktyg har delats upp i logiska grupper: formgivande ritverktyg (cirkel, rektangel) frihandsritverktyg (pensel) transformverktyg som ställer till ett lagers geometri fyllverktyg (som fyll eller toning) vyverktyg (som inte ändrar bildpunkter, men ändrar sättet du ser duken, som zoomning) markeringsverktyg (som ändrar markeringsmasken) Vertygsgränssnittet beskrivs i dokumentationen av programmeringsgränssnittet för KisTool. Det finns tre delklasser: KisToolPaint, KisToolNonPaint och KisToolShape (som egentligen är en delklass av KisToolPaint) som specialiserar KisTool för rituppgifter (dvs. ändra bildpunkter), icke-rituppgifter och rituppgifter för former. Ett verktyg har en grafisk inställningskomponent, precis som filter. För närvarande visas de grafiska inställningskomponenterna i en flik i ett dockat fönster. Det kan komma att ändras till en rad under huvudmenyn (som då ersätter verktygsraden) för &chalk; 2.0, men för närvarande ska inställningskomponenter konstrueras för att få plats under en flik. Som alltid är det bäst att använda &TQt; Designer för konstruktion av inställningskomponenten. Ett bra exempel på ett verktyg är stjärnverktyget: kis_tool_star.cpp Makefile.am tool_star_cursor.png wdg_tool_star.ui kis_tool_star.h Makefile.in tool_star.h chalktoolstar.desktop tool_star.cpp tool_star.png Som du ser, behöver du två bilder: en för markören och en för verktygslådan. tool_star.cpp laddar bara insticksprogrammet, på liknande sätt som vi har sett ovan. Det matnyttiga finns i implementeringen: KisToolStar::KisToolStar() : KisToolShape(i18n("Star")), m_dragging (false), m_currentImage (0) { setName("tool_star"); setCursor(KisCursor::load("tool_star_cursor.png", 6, 6)); m_innerOuterRatio=40; m_vertices=5; } Konstruktorn skapar det interna namnet, som inte översätts, och anropet till superklassen anger det synliga namnet. Vi laddar också markörbilden och tilldelar värden till ett antal variabler. void KisToolStar::update (KisCanvasSubject *subject) { KisToolShape::update (subject); if (m_subject) m_currentImage = m_subject->currentImg(); } Metoden update() anropas när verktyget väljes. Det är inte en metod i KisTool, utan en metod i KisCanvasObserver. Dukobservatörer underrättas så fort något ändras i vyn, vilket kan vara användbart för verktyg. Följande metoder (buttonPress, move och buttonRelease) anropas av &chalk; när inmatningsenheten (mus, penna, radergummi, etc.) trycks ner, flyttas eller släpps upp. Observera att förflyttningshändelser också avges om musknappen inte är nertryckt. Händelserna är inte de vanliga &TQt;-händelserna, utan syntetiska händelser i &chalk;, eftersom vi drar nytta av trick på låg nivå för att få tillräckligt med händelser för att rita jämna linjer. Normalt kastar verktygslådor som &TQt; (och GTK) händelser om de är för upptagna för att hantera dem, och vi vill ha dem alla. void KisToolStar::buttonPress(KisButtonPressEvent *event) { if (m_currentImage && event->button() == LeftButton) { m_dragging = true; m_dragStart = event->pos(); m_dragEnd = event->pos(); m_vertices = m_optWidget->verticesSpinBox->value(); m_innerOuterRatio = m_optWidget->ratioSpinBox->value(); } } void KisToolStar::move(KisMoveEvent *event) { if (m_dragging) { // erase old lines on canvas draw(m_dragStart, m_dragEnd); // move (alt) or resize star if (event->state() & TQt::AltButton) { KisPoint trans = event->pos() - m_dragEnd; m_dragStart += trans; m_dragEnd += trans; } else { m_dragEnd = event->pos(); } // draw new lines on canvas draw(m_dragStart, m_dragEnd); } } void KisToolStar::buttonRelease(KisButtonReleaseEvent *event) { if (!m_subject || !m_currentImage) return; if (m_dragging && event->button() == LeftButton) { // erase old lines on canvas draw(m_dragStart, m_dragEnd); m_dragging = false; if (m_dragStart == m_dragEnd) return; if (!m_currentImage) return; if (!m_currentImage->activeDevice()) return; KisPaintDeviceSP device = m_currentImage->activeDevice ();; KisPainter painter (device); if (m_currentImage->undo()) painter.beginTransaction (i18n("Star")); painter.setPaintColor(m_subject->fgColor()); painter.setBackgroundColor(m_subject->bgColor()); painter.setFillStyle(fillStyle()); painter.setBrush(m_subject->currentBrush()); painter.setPattern(m_subject->currentPattern()); painter.setOpacity(m_opacity); painter.setCompositeOp(m_compositeOp); KisPaintOp * op = KisPaintOpRegistry::instance()->paintOp(m_subject->currentPaintop(), m_subject->currentPaintopSettings(), &painter); painter.setPaintOp(op); // Painter takes ownership vKisPoint coord = starCoordinates(m_vertices, m_dragStart.x(), m_dragStart.y(), m_dragEnd.x(), m_dragEnd.y()); painter.paintPolygon(coord); device->setDirty( painter.dirtyRect() ); notifyModified(); if (m_currentImage->undo()) { m_currentImage->undoAdapter()->addCommand(painter.endTransaction()); } } } Metoden draw() är en intern metod i KisToolStar som ritar stjärnans kontur. Vi anropar den från metoden move() för att ge användaren återmatning om stjärnans storlek och form. Observera att vi använder TQt::NotROP rasteroperationen, vilket betyder att anropa draw() en andra gång med samma start- och slutpunkt gör att stjärnan tas bort. void KisToolStar::draw(const KisPoint& start, const KisPoint& end ) { if (!m_subject || !m_currentImage) return; KisCanvasController *controller = m_subject->canvasController(); KisCanvas *canvas = controller->kiscanvas(); KisCanvasPainter p (canvas); QPen pen(TQt::SolidLine); KisPoint startPos; KisPoint endPos; startPos = controller->windowToView(start); endPos = controller->windowToView(end); p.setRasterOp(TQt::NotROP); vKisPoint points = starCoordinates(m_vertices, startPos.x(), startPos.y(), endPos.x(), endPos.y()); for (uint i = 0; i < points.count() - 1; i++) { p.drawLine(points[i].floorQPoint(), points[i + 1].floorQPoint()); } p.drawLine(points[points.count() - 1].floorQPoint(), points[0].floorQPoint()); p.end (); } Metoden setup() är fundamental: Här skapar vi åtgärden som kommer att stoppas in i verktygslådan så att användare verkligen kan välja verktyget. Vi tilldelar också en snabbtangent. Observera att en del programknep används här: kom ihåg att vi skapade en instans av verktyget för varje inmatningsenhet. Det betyder också att vi anropar setup() för varje inmatningsenhet och att en åtgärd med samma namn läggs till flera gånger i åtgärdssamlingen. Men allt verkar fungera, så varför bekymra sig? void KisToolStar::setup(TDEActionCollection *collection) { m_action = static_cast<TDERadioAction *>(collection->action(name())); if (m_action == 0) { TDEShortcut shortcut(TQt::Key_Plus); shortcut.append(TDEShortcut(TQt::Key_F9)); m_action = new TDERadioAction(i18n("&Star"), "tool_star", shortcut, this, TQ_SLOT(activate()), collection, name()); TQ_CHECK_PTR(m_action); m_action->setToolTip(i18n("Draw a star")); m_action->setExclusiveGroup("tools"); m_ownAction = true; } } Metoden starCoordinates() innehåller en del knepig matematik, men den är inte särskilt intressant i beskrivningen av hur man skapar verktygsinsticksprogram. KisPoint KisToolStar::starCoordinates(int N, double mx, double my, double x, double y) { double R=0, r=0; Q_INT32 n=0; double angle; vKisPoint starCoordinatesArray(2*N); // the radius of the outer edges R=sqrt((x-mx)*(x-mx)+(y-my)*(y-my)); // the radius of the inner edges r=R*m_innerOuterRatio/100.0; // the angle angle=-atan2((x-mx),(y-my)); //set outer edges for(n=0;n<N;n++){ starCoordinatesArray[2*n] = KisPoint(mx+R*cos(n * 2.0 * M_PI / N + angle),my+R*sin(n *2.0 * M_PI / N+angle)); } //set inner edges for(n=0;n<N;n++){ starCoordinatesArray[2*n+1] = KisPoint(mx+r*cos((n + 0.5) * 2.0 * M_PI / N + angle),my+r*sin((n +0.5) * 2.0 * M_PI / N + angle)); } return starCoordinatesArray; } Metoden createOptionWidget() anropas för att skapa den grafiska inställningskomponenten som &chalk; visar under fliken. Eftersom det finns ett verktyg per inmatningsenhet och per vy, kan tillståndet hos ett verktyg lagras i verktyget. Metoden anropas bara en gång: den grafiska inställningskomponenten lagras och hämtas nästa gång verktyget aktiveras. TQWidget* KisToolStar::createOptionWidget(TQWidget* parent) { TQWidget *widget = KisToolShape::createOptionWidget(parent); m_optWidget = new WdgToolStar(widget); TQ_CHECK_PTR(m_optWidget); m_optWidget->ratioSpinBox->setValue(m_innerOuterRatio); QGridLayout *optionLayout = new QGridLayout(widget, 1, 1); super::addOptionWidgetLayout(optionLayout); optionLayout->addWidget(m_optWidget, 0, 0); return widget; } Verktyg är relativt enkla insticksprogram att skapa. Du måste kombinera gränssnitten KisTool och KisCanvasObserver för att skapa ett verktyg effektivt. Ritoperationer är en av de mest uppfinningsrika typer av insticksprogram i Chalk (tillsammans med färgrymder som kan användas som insticksprogram). En ritoperation definierar hur verktyg ändrar bildpunkterna de berör. Retuschspruta, penna utan kantutjämning eller bildpunktspensel med kantutjämning är alla ritoperationer. Men du skulle kunna, med en stor mängd arbete, skapa en ritoperation som läser Corel Paint XML-penseldefinitioner och använder dem för att bestämma hur man ska rita Ritoperationer instantieras när ett ritverktyg tar emot händelsen mouseDown och tas bort när händelsen mouseUp tas emot av ett ritverktyg. Under mellantiden kan ritoperationen hålla reda på tidigare positioner och annan information, som trycknivåer om användaren använder en styrplatta. Den grundläggande åtgärden för en ritoperation är att ändra bildpunkter vid ett ritverktygs markörposition. Det kan bara göras en gång, eller så kan ritoperationen begära att få utföras med regelbundna intervall, med användning av en tidtagare. Det första fallet är användbart för en pennliknande ritoperation, och det andra naturligtvis för en ritoperation som liknar en retuschspruta. Ritoperationer kan ha en liten grafisk inställningskomponent som placeras i en verktygsrad. Alltså måste grafiska inställningskomponenter för ritoperationer ha en horisontell layout som inte är högre än en knapp i en verktygsrad, annars skulle &chalk; se mycket konstigt ut. Låt oss titta på ett enkelt insticksprogram för en ritoperation,, en som visar en viss mängd programbaserad intelligens. För det första finns en fabrik definierad i deklarationsfilen. Fabriken skapar en ritoperation när det aktiva verktyget behöver en: public: KisSmearyOpFactory() {} virtual ~KisSmearyOpFactory() {} virtual KisPaintOp * createOp(const KisPaintOpSettings *settings, KisPainter * painter); virtual KisID id() { return KisID("paintSmeary", i18n("Smeary Brush")); } virtual bool userVisible(KisColorSpace * ) { return false; } virtual TQString pixmap() { return ""; } }; Fabriken innehåller också KisID med det offentliga och privata namnet på ritoperationen, och kan valfritt returnera en punktavbildning. &chalk; kan därefter visa punktavbildningen tillsammans med namnet som en visuell identifikation av ritoperationen. Till exempel skulle ritoperationen målarkniv ha en bild av ett sådant verktyg. Försäkra dig om att ritoperationens privata namn inte råkar i konflikt med en annan ritoperation! Implementeringen av ritoperationer är mycket rättfram: KisSmearyOp::KisSmearyOp(KisPainter * painter) : KisPaintOp(painter) { } KisSmearyOp::~KisSmearyOp() { } void KisSmearyOp::paintAt(const KisPoint &pos, const KisPaintInformation& info) { Metoden paintAt() är stället där allt händer för ritoperationer. Metoden har två parametrar, den aktuella positionen (som anges med flyttal, inte i hela bildpunkter) och objektet KisPaintInformation, som innehåller tryck, x, y, lutning och förflyttningsvektor, och som kan utökas med ytterligare information i framtiden. if (!m_painter->device()) return; KisBrush *brush = m_painter->brush(); En KisBrush är representationen av en Gimp penselfil: det vill säga en mask, antingen en enda mask eller en serie masker. I själva verket använder vi inte penseln här, utom för att bestämma ritpunkten under markören. Q_ASSERT(brush); if (!brush) return; if (! brush->canPaintFor(info) ) return; KisPaintDeviceSP device = m_painter->device(); KisColorSpace * colorSpace = device->colorSpace(); KisColor kc = m_painter->paintColor(); kc.convertTo(colorSpace); KisPoint hotSpot = brush->hotSpot(info); KisPoint pt = pos - hotSpot; // Split the coordinates into integer plus fractional parts. The integer // is where the dab will be positioned and the fractional part determines // the sub-pixel positioning. Q_INT32 x, y; double xFraction, yFraction; splitCoordinate(pt.x(), &x, &xFraction); splitCoordinate(pt.y(), &y, &yFraction); KisPaintDeviceSP dab = new KisPaintDevice(colorSpace, "smeary dab"); TQ_CHECK_PTR(dab); Vi ändrar inte bildpunkterna på en uppritningsenhet direkt: istället skapar vi en liten uppritningsenhet, en dutt, och sammanfogar den med den aktuella uppritningsenheten. m_painter->setPressure(info.pressure); I enlighet med kommentarerna, utför följande kodstycke lite programarbete för att skapa själva dutten. I detta fall ritar vi ett antal linjer. När ritoperationen är klar, kommer linjernas längd, position och tjocklek bero på tryck och färgmängd, och vi har skapat en styv, smetig oljefärgspensel. Men jag har inte haft tid att avsluta detta ännu. // Compute the position of the tufts. The tufts are arranged in a line // perpendicular to the motion of the brush, i.e, the straight line between // the current position and the previous position. // The tufts are spread out through the pressure KisPoint previousPoint = info.movement.toKisPoint(); KisVector2D brushVector(-previousPoint.y(), previousPoint.x()); KisVector2D currentPointVector = KisVector2D(pos); brushVector.normalize(); KisVector2D vl, vr; for (int i = 0; i < (NUMBER_OF_TUFTS / 2); ++i) { // Compute the positions on the new vector. vl = currentPointVector + i * brushVector; KisPoint pl = vl.toKisPoint(); dab->setPixel(pl.roundX(), pl.roundY(), kc); vr = currentPointVector - i * brushVector; KisPoint pr = vr.toKisPoint(); dab->setPixel(pr.roundX(), pr.roundY(), kc); } vr = vr - vl; vr.normalize(); Till sist överför vi dutten med en blocköverföring på den ursprungliga uppritningsenheten och talar om för uppritaren att vi har påverkat en liten rektangel på uppritningsenheten. if (m_source->hasSelection()) { m_painter->bltSelection(x - 32, y - 32, m_painter->compositeOp(), dab.data(), m_source->selection(), m_painter->opacity(), x - 32, y -32, 64, 64); } else { m_painter->bitBlt(x - 32, y - 32, m_painter->compositeOp(), dab.data(), m_painter->opacity(), x - 32, y -32, 64, 64); } m_painter->addDirtyRect(QRect(x -32, y -32, 64, 64)); } KisPaintOp * KisSmearyOpFactory::createOp(const KisPaintOpSettings */*settings*/, KisPainter * painter) { KisPaintOp * op = new KisSmearyOp(painter); TQ_CHECK_PTR(op); return op; } Det är allt: ritoperationer är enkla och kul! Vyinsticksprogram är de konstigaste i hela gänget: Ett vyinsticksprogram är en vanlig KPart som kan tillhandahålla en viss mängd användargränssnitt och en del funktioner. Histogramfliken är till exempel ett vyinsticksprogram, liksom rotationsdialogrutan. &chalk; arbetar med den vanliga filterarkitekturen för filer i &koffice;. Det finns en handledning, något gammal, men fortfarande användbar, på: . Det är troligtvis bäst att samarbeta med &chalk;-gruppen vid utveckling av filfilter och att göra utvecklingen i &koffice; filterträd. Observera att du kan prova filter utan att köra &chalk; genom att använda verktyget koconverter. Filter har två sidor: import och export. De är oftast två olika insticksprogram som kan dela viss kod. De viktiga posterna i Makefile.am är: service_DATA = chalk_XXX_import.desktop chalk_XXX_export.desktop servicedir = $(kde_servicesdir) kdelnk_DATA = chalk_XXX.desktop kdelnkdir = $(kde_appsdir)/Office libchalkXXXimport_la_SOURCES = XXXimport.cpp libchalkXXXexport_la_SOURCES = XXXexport.cpp METASOURCES = AUTO Oberoende av om du skapar ett importfilter eller ett exportfilter, är kontentan av arbetet alltid att implementera följande funktion: virtual KoFilter::ConversionStatus convert(const QCString& from, const QCString& to); Det är inställningarna i filen .desktop som avgör på vilket sätt ett filter konverterar: Import: X-TDE-Export=application/x-chalk X-TDE-Import=image/x-xcf-gimp X-TDE-Weight=1 X-TDE-Library=libchalkXXXimport ServiceTypes=KOfficeFilter Export: X-TDE-Export=image/x-xcf-gimp X-TDE-Import=application/x-chalk ServiceTypes=KOfficeFilter Type=Service X-TDE-Weight=1 X-TDE-Library=libchalkXXXexport Och ja, MIME-typen som är vald i exemplet är en antydan: Snälla, snälla, implemetera ett XCF-filter! Det stora problemet med importfilter är förstås koden för att läsa data på disk. Standardkoden för att anropa denna kod är ganska enkel: Observera: Vi borde verkligen hitta ett sätt att göra det möjligt för &chalk; att behålla en fil öppen och bara läsa data alltefter det behövs, istället för att kopiera hela innehållet till den interna representationen i uppritningsenheten. Men det skulle betyda gränssnitt för datahantering som känner till TIFF-filer och så vidare, och det är för närvarande inte implementerat. Det skulle vara idealiskt om vissa filfilter kunde implementera en klass, preliminärt kallad KisFileDataManager, skapa ett objekt av den instansen med den aktuella filen och skicka den till KisDoc. Men &chalk; hanterar lagring per lager, inte per dokument, så det skulle vara en svårt omskrivning. KoFilter::ConversionStatus XXXImport::convert(const QCString&, const QCString& to) { if (to != "application/x-chalk") return KoFilter::BadMimeType; KisDoc * doc = dynamic_cast<KisDoc*>(m_chain -> outputDocument()); KisView * view = static_cast<KisView*>(doc -> views().getFirst()); TQString filename = m_chain -> inputFile(); if (!doc) return KoFilter::CreationError; doc -> prepareForImport(); if (!filename.isEmpty()) { KURL url(filename); if (url.isEmpty()) return KoFilter::FileNotFound; KisImageXXXConverter ib(doc, doc -> undoAdapter()); if (view != 0) view -> canvasSubject() -> progressDisplay() -> setSubject(&ib, false, true); switch (ib.buildImage(url)) { case KisImageBuilder_RESULT_UNSUPPORTED: return KoFilter::NotImplemented; break; case KisImageBuilder_RESULT_INVALID_ARG: return KoFilter::BadMimeType; break; case KisImageBuilder_RESULT_NO_URI: case KisImageBuilder_RESULT_NOT_LOCAL: return KoFilter::FileNotFound; break; case KisImageBuilder_RESULT_BAD_FETCH: case KisImageBuilder_RESULT_EMPTY: return KoFilter::ParsingError; break; case KisImageBuilder_RESULT_FAILURE: return KoFilter::InternalError; break; case KisImageBuilder_RESULT_OK: doc -> setCurrentImage( ib.image()); return KoFilter::OK; default: break; } } return KoFilter::StorageCreationError; } Detta är avsett att vara ett importfilter, så om det inte anropas för att konvertera till en bild i &chalk;, är det något som är fel. Filterkedjan har redan skapat ett utdatadokument åt oss. Vi måste typkonvertera den till KisDocM, eftersom &chalk;-dokument kräver särskilt behandling. Det skulle i själva verket inte vara en dum idé att kontrollera att resultatet av typkonverteringen inte är 0, eftersom om den är det kommer importen att misslyckas. Om vi anropar filtret från det grafiska gränssnittet, försöker vi få vyn. Om det finns en vy, kan konverteringskoden försöka uppdatera förloppsraden. Filtret har filnamnet på indatafilen åt oss. KisDoc måste förberedas för import. Vissa inställningar initieras och ångra inaktiveras. Annars skulle du kunna ångra tillägg av lager som utförs av importfiltret, och det är ett konstigt beteende. Jag har valt att implementera själva importkoden i en separat klass som jag instantierar här. Du kan också lägga all din kod direkt i den här metoden, men det skulle vara lite stökigt. Min importkod returnerar en statuskod, som jag sedan kan använda för att ange status för importfiltret. &koffice; tar hand om att visa felmeddelanden. Om vi har lyckats skapa KisImage sätter vi dokumentets aktuella bild till vår nyskapade bild. Därefter är vi klara: return KoFilter::OK;.