&chalk; on tänu pluginatele lõputult laiendatav. Pluginateks on tööriistad, filtrid, suur osa kasutajaliidesest ning isegi värviruumid. &chalk; kasutab kuut tüüpi pluginaid: värviruumid — kanalite kirjeldamiseks, millest koosneb üks piksel tööriistad — kõik, mida saab teha hiirega või graafikalauaga joonistamisoperatsioonid — tööriistadele kaasatavad joonistamisefektid pildifiltrid — kõigi pikslite või ka lihtsalt kihi valitud pikslite muutmiseks vaatepluginad — Chalk kasutajaliidese laiendamiseks uute dialoogide, palettide ja operatsioonidega import/eksportfiltrid — igat laadi pildivormingute lugemiseks ja kirjutamiseks &chalk; ise koosneb kolmest teegist ja kataloogis mõne ühise tugiklassiga: chalkcolor, chalkimage ja chalkui. Objekte tuvastab &chalk;s KisID, mis on unikaalse tõlkimata stringi (kasutatakse näiteks salvestamisel) ja graafilise kasutajaliidese jaoks tõlgitud stringi kombinatsioon. Sõnake ühilduvuse kohta: &chalk; on endiselt arendamisjärgus. &chalk; 1.5 ja 1.6 vahel pole ette näha kuigi palju API muudatusi, aga mõned võivad siiski olla. &chalk; 1.6 ja 2.0 vahele jääb üleminek &Qt;3 pealt &Qt;4 peale, &kde;3 pealt &kde;4 peale, automake'i pealt cmake'i peale, mis tähendab väga suuri muudatusi. Kui arendad pluginat &chalk; tarbeks ja pead paremaks teha seda &chalk; Subversioni hoidlas, võime me aidata sind portimisel. Muudatused võivad muuta ka käesoleva dokumendi vähemal või rohkemal määral iganenuks. Kontrolli alati oma süsteemi paigaldatud uusimat API dokumentatsiooni või päisefaile. Esimene teek on chalkcolor. See laadib värviruumipluginad. Värviruumiplugin peab teostama KisColorSpace abstraktse klassi või kui uue värviruumi põhiomadusi teostab lcms (), siis laiendama klassi KisAbstractColorSpace. Teeki chalkcolor saavad kasutada teised rakendused ja see ei sõltu &koffice;'ist. Teek libchalkimage laadib filtrid ja joonistamisoperatsioonide pluginad ning vastutav pildiandmetega töötamise eest: pikslite muutmine, komposiit- ja joonistamisoperatsioonid. Ka pintsleid, palette, üleminekuid ja mustreid laadib libchalkimage. Meie kindel eesmärk on muuta libchalkimage sõltumatuks &koffice;'ist, kuid praegu jagame me veel &koffice;'iga üleminekute laadimise koodi. Praegu pole väga lihtne lisada &chalk; uut tüüpi ressursse, näiteks pintsleid, palette, üleminekuid ja mustreid. (Uute pintslite, palettide, üleminekute ja mustrite lisamine on loomulikult lihtne.) &chalk; järgib selles osas projekti Create () suuniseid. Photoshopi pintslifaili vormingu toetuse lisamine vajab libchalkimage'i häkkimist, GIMP-i pintslite lisamine samas aga mitte. ChalkImage laadib järgmist tüüpi pluginad: &chalk; filtrid peavad laiendama ja teostama abstraktse klassi KisFilter, KisFilterConfiguration ja võimaluse korral KisFilterConfigurationWidget. Filtri näiteks on teravustamismask. Joonistamisoperatsioonid on operatsioonide kogumid, mida saavad kasutada joonistamistööriistad, näiteks vabakäsi või ring. Joonistamisoperatsioonide näiteks on pliiats, pihusti või kustutaja. Joonistamisoperatsioonid peavad laiendama KisPaintop baasklassi. Uute joonistamisoperatsioonide näiteks on kriidipintsel, õlimaalipintsel või keerukas programmeeritav pintsel. Teek libchalkui laadib tööriistad ja vaatepluginad. Teek on &koffice;'i komponent, kuid sisaldab ka mitmeid vidinaid, mis on abiks graafikarakendustele. Võimalik, et see teek jagatakse 2.0 ajaks teekideks chalkpart ja chalkui. Praegu ei ole skriptikirjutajatel sellele teegile ligipääsu ning pluginakirjutajatel on lubatud seda kasutada ainult tööriistade või vaatepluginate kirjutamisel. ChalkUI laadib järgmist tüüpi pluginad: Tööriistad tulenevad klassist KisTool või mõnest spetsiaalsest tööriistade baasklassist, näiteks KisToolPaint, KisToolNonPaint või KisToolFreehand. Uus tööriist võib olla esiplaani objekti valimise tööriist. Joonistamistööriistad (nende hulka käivad tööriistad, mis joonistavad valikuga) võivad kasutada iga joonistamisoperatsiooni määramaks, kuidas piksleid muudetakse. Vaatepluginad on tavalised KParts, mis kasutavad kxmlgui enda sobitamiseks &chalk; kasutajaliidesesse. Menüükirjed, dialoogid, tööriistaribad — mis tahes kasutajaliidese laiendus võib olla vaateplugin. Õigupoolest on üsna olulisi funktsioone, näiteks &chalk; skriptitoetus, kirja pandud vaatepluginana. Import/eksportfiltrid on &koffice;'i filtrid, KoFilter alamklassid. Filtrid loevad ja kirjutavad pildiandmeid mis tahes pildivormingutest ja pildivormingutesse. Uue &chalk; import/eksportfiltri näiteks on PDF-filter. Filtreid laadivad &koffice;'i teegid. Pluginad kirjutatakse C++ keeles ning need võivad kasutada kogu &kde;, &Qt; ja &chalk; API-t. Ainult vaatepluginad peavad kasutama &koffice;'i API-t. Aga ära muretse: &chalk; API on väga selge ja päris ulatuslikult dokumenteeritud (vaba tarkvara kohta) ning oma esimese filtri koodi kirjutamine üsna lihtne. Kui sa ei soovi C++ keelt kasutada, võid kirjutada skriptid Pythoni või Ruby keeles. See on siiski täiesti teine asi ning praegu ei saa kirjutada tööriistu, värviruume, joonistamisoperatsioone ega import/eksportfiltreid skriptidena. &chalk; pluginad kasutavad laadimiseks &kde; komponentide mehhanismi (KPart), mistõttu asjakohane on ka komponentide dokumentatsioon, mille leiab aadressil . Sinu distributsioon peaks olema paigaldanud vajalikud päisefailid koos &chalk;ga või siis jaganud päisefailid &koffice;'i või &chalk; arenduspaketti (devel). &chalk; avaliku API dokumentatsiooni leiab aadressil . &kde; 3.x ja seega ka &koffice; 1.5 ja 1.6 kasutavad automake'i. &kde; 4.0 ja &koffice; 2.0 kasutavad cmake'i. Käesolev tutvustus kirjeldab pluginate loomist automake'iga. Pluginad on &kde; moodulid ja nii tuleb neid ka sildistada failis Makefile.am. Filtrid, tööriistad, joonistamisoperatsioonid, värviruumid ja import/eksportfiltrid vajavad .desktop-faile; vaatepluginad lisaks veel KXMLGui faili pluginname.rc. Lihtsaim viis alustada on teha väljavõte projektist chalk-plugins &koffice;'i Subversioni hoidlas ning kasutada seda oma projekti baasina. Me kavatseme valmistada &chalk; pluginamallid KDevelopi tarbeks, kuid pole seni veel jõudnud seda teha. Vaatame plugina mooduli kondikava. Kõigepealt Makefile.am. Seda kasutab &kde; makefile'i genereerimiseks, mis ehitab plugina: kde_services_DATA = chalkLIBRARYNAME.desktop INCLUDES = $(all_includes) chalkLIBRARYNAME_la_SOURCES = sourcefile1.cc sourcefile2.cc 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 See on filtriplugina makefile. Asenda LIBRARYNAME oma töö nimega ja asi valmis. Kui sinu plugin on vaateplugin, tuleb paigaldada ka .rc-fail menüüribade ja tööriistaribade kirjetega. Samuti võib olla vajalik paigaldada kursorid ja ikoonid. Seda kõike saab teha tavapärase &kde; Makefile.am maagiaga: 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 .desktop-fail annab teada plugina tüübi: [Desktop Entry] Encoding=UTF-8 Icon= Name=Kasutajale nähtav nimi ServiceTypes=Chalk/Filter Type=Service X-KDE-Library=chalkLIBRARYNAME X-KDE-Version=2 Võimalikud teenusetüübid (ServiceTypes) on järgmised: Chalk/Filter Chalk/Paintop Chalk/ViewPlugin Chalk/Tool Chalk/ColorSpace Failide import- ja eksportfiltrid kasutavad &koffice;'i üldist filtriraamistikku ja neist tuleb eraldi juttu. Vaja läheb ka veidi trafaretset koodi, mille &kde; komponentide raamistik kutsub välja plugina initsialiseerimiseks — päisefail ja teostusfail. Päisefail: #ifndef TOOL_STAR_H_ #define TOOL_STAR_H_ #include <tdeparts/plugin.h> /** * A module that provides a star tool. */ class ToolStar : public KParts::Plugin { Q_OBJECT public: ToolStar(QObject *parent, const char *name, const QStringList &); virtual ~ToolStar(); }; #endif // TOOL_STAR_H_ Ja teostusfail: #include <kinstance.h> #include <kgenericfactory.h> #include <kis_tool_registry.h> #include "tool_star.h" #include "kis_tool_star.h" typedef KGenericFactory<ToolStar> ToolStarFactory; K_EXPORT_COMPONENT_FACTORY( chaltdetoolstar, ToolStarFactory( "chalk" ) ) ToolStar::ToolStar(QObject *parent, const char *name, const QStringList &) : KParts::Plugin(parent, name) { setInstance(ToolStarFactory::instance()); if ( parent->inherits("KisToolRegistry") ) { KisToolRegistry * r = dynamic_cast<KisToolRegistry*>( parent ); r -> add(new KisToolStarFactory()); } } ToolStar::~ToolStar() { } #include "tool_star.moc" Tööriistad laadib tööriistaregister ja need registreerivad ennast tööriistaregistris. Pluginad, nagu ka tööriistad, filtrid ja joonistamisoperatsioonid laaditakse ainult üks kord; vaatepluginad laaditakse iga loodava vaate korral. Arvesta, et me registreerime üldiselt vabrikuid (factory). Näiteks tööriistade korral luuakse tööriista uus isend iga viida jaoks (hiir, stiilus, kustutaja). Uus joonistamisoperatsioon luuakse alati, kui tööriist saab hiirenupu vajutamise sündmuse. Filtrid kutsuvad välja filtriregistri: if (parent->inherits("KisFilterRegistry")) { KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent); manager->add(new KisFilterInvert()); } Joonistusoperatsioonid joonistusoperatsioonide registri: if ( parent->inherits("KisPaintOpRegistry") ) { KisPaintOpRegistry * r = dynamic_cast<KisPaintOpRegistry*>(parent); r -> add ( new KisSmearyOpFactory ); } Värviruumid värviruumide registri (mõningate komplikatsioonidega): if ( parent->inherits("KisColorSpaceFactoryRegistry") ) { KisColorSpaceFactoryRegistry * f = dynamic_cast<isColorSpaceFactoryRegistry*>(parent); KisProfile *defProfile = new KisProfile(cmsCreate_sRGBProfile()); f->addProfile(defProfile); KisColorSpaceFactory * csFactory = new KisRgbColorSpaceFactory(); f->add(csFactory); KisColorSpace * colorSpaceRGBA = new KisRgbColorSpace(f, 0); KisHistogramProducerFactoryRegistry::instance() -> add( new KisBasicHistogramProducerFactory<KisBasicU8HistogramProducer> (KisID("RGB8HISTO", i18n("RGB8 Histogram")), colorSpaceRGBA) ); } Vaatepluginad ennast ei registreeri ning nad saavad ligipääsu KisView-objektile: if ( parent->inherits("KisView") ) { setInstance(ShearImageFactory::instance()); setXMLFile(locate("data","chalkplugins/shearimage.rc"), true); (void) new TDEAction(i18n("&Shear Image..."), 0, 0, this, SLOT(slotShearImage()), actionCollection(), "shearimage"); (void) new TDEAction(i18n("&Shear Layer..."), 0, 0, this, SLOT(slotShearLayer()), actionCollection(), "shearlayer"); m_view = (KisView*) parent; } Arvesta, et see tähendab, et vaateplugin luuakse igale vaatele, mille kasutaja loob; vaate poolitamine tähendab kõigi vaatepluginate taaslaadimist. &chalk; laadib pluginad versiooniga X-KDE-Version=2, mille määrab .desktop-fail. &chalk; 1.6 pluginad on arvatavasti binaarselt ühildumatud 1.5 pluginatega ja vajavad versiooni 3. &chalk; 2.0 pluginad vajavad versiooni 3. Jah, see pole just täiesti loogiline. Värviruumid teostavad KisColorSpace ehtsa virtuaalse klassi. Värviruume on kaht tüüpi: need, mis võivad värviruumide teisendamiseks kasutada lcms'i ja need, mis on lcms'i jaoks liiga veidrad. Esimese näited on cmyk, rgb, yuv. Teise näiteks on vesivärvid. Värviruume, mis kasutavad lcms'i, saab tuletada klassit KisAbstractColorSpace või mõnest baasklassist, mis on mõeldud teatud bittide arvuga kanalile. Värviruumi teostamine on üpris lihtne. Põhimõtteliselt on värviruum lihtsalt baidimassiiv. Baitide tõlgendamine on värviruumi ülesanne. Näiteks piksel 16-bitises GrayA värviruumis koosneb neljast baidist: kaks baiti halli väärtuse ja kaks baiti alfa väärtuse jaoks. Sa võid vabalt kasutada oma värviruumi teostuses struktuure piksli mälupaigutuse jaoks, aga seda esindust ei ekspordita. &chalk; saab sellest, millistest kanalitest ja kanalitüüpidest sinu värviruumi pikslid koosnevad, teada ainult klassi KisChannelInfo kaudu. Filtrid ja joonistamisoperatsioonid kasutavad oma tööks arvukaid meetodeid, mida pakub KisColorSpace. Paljudel juhtudel toimib vaikimis teostus klassis KisAbstractColorSpace, kuid see on aeglasem kui kohandatud teostus omaenda värviruumis, sest KisAbstractColorSpace teisendab kõik pikslid 16-bitiseks L*a*b-iks ja tagasi. (http://websvn.kde.org/trunk/koffice/chalk/chalkcolor/kis_channelinfo.h) See klass kirjeldab kanaleid, millest koosneb üks piksel antud värviruumis. Kanalil on järgmised olulised tunnused: nimi, mida kuvatakse kasutajaliideses asukoht: bait, kus baidid tähistavad antud kanali algust pikslis. tüüp: värv. alfa, substants või substraat. Värv on puhas värv, alfa läbipaistvus, substants tähistab pigmendi või millegi sellise kogust, substraat tähistab lõuendit. väärtusetüüp: bait, lühike või pikk täisarv, murdarv või midagi muud. suurus: antud kanali baitide arv värv: antud kanali QColor esindus kasutajaliidese tarbeks, näiteks histogrammis. lühend kasutajaliidese tarbeks, kui seal napib ruumi Uue värvi saamiseks on võimalik piksleid mitmel moel kombineerida. Klass KisCompositeOp kirjeldab neist enamikku: see kogum ei ole kuigi lihtsalt laiendatav, kui mitte häkkida teeki chalkcolor. Värviruumi plugin võib toetada võimalike komposiitoperatsioonide mis tahes alamhulka, aga selles peab alati sisalduma "OVER" (sama mis "NORMAL") ja "COPY". Ülejäänud on enam-vähem suvalised, ehkki: mida rohkem, seda parem. Ehtsa virtuaalse klassi KisColorSpace meetodid võib jagada mitmesse rühma: teisendamine, tuvastamine ja manipuleerimine. Kõik klassid peavad suutma teisendada pikslit 8-bitisest RGB-st ja 8-bitisesse RGB-sse (s.t. QColor), võimaluse korral ka 16-bitisest L*a*b-ist ja 16- bitisesse L*a*b-i. Lisaks on ka meetod, mis võimaldab teisendada mis tahes värviruumist aktiivsesse värviruumi. Värviruume kirjeldavad KisChannelInfo vektor, kanalite arv, baitide arv ühes pikslis, High Dynamic Range piltide toetus või selle puudumine ja veel mitmed tunnused. Manipuleerimise näiteks on kahe piksli kombineerimine uueks piksliks: bitBlt, pikslite tumendamine või konvolveerimine. Kõiki meetodeid, mida värviruumis tuleb teostada, kirjeldab põhjalikult API dokumentatsioon. Klass KisAbstractColorSpace teostab paljud KisColorSpace virtuaalsed meetodid lcms teegi funktsioonide abil. Klassi KisAbstractColorSpace kohal asuvad baasvärviruumiklassid 8- ja 16-bitistele täisarvulistele ning 16- ja 31-bitistele murdarvulistele värviruumidele, mis kirjeldavad bitisügavuste vahel liikumise ühiseid operatsioone. Filtrid on pluginad, mis uurivad piksleid kihis ja seejärel muudavad neid. Kuigi &chalk; kasutab pikslite salvestamiseks tõhusalt klotsmälu taustaprogrammi, ei pruugi filtri kirjutaja selle pärast muretseda. Kirjutades filtripluginat &Java; pildi-API-le, Photoshopile või GIMP-ile, tuleb muret tunda klotside servade pärast ja klotsid kokku klopsida: &chalk; peidab teostuse detailid. Arvesta, et teoreetiliselt on hõlpus asendada praegune klots-pildiandmete salvestamine taustaprogramm mõne muuga, kuid jõudluse huvides ei ole see taustaprogramm ise praegu tegelikult plugin. &chalk; kasutab piksliväärtuste lugemiseks ja kirjutamiseks iteraatoreid. Teine võimalus on lugeda piksliplokk mälupuhvrisse, seda töödelda ja siis taas plokina tagasi kirjutada. Kuid see ei pruugi olla tingimata tõhusam, õieti võib see isegi olla aeglasem kui iteraatorite kasutamine, aga muidugi on see omajagu ka maitseasi. Vaata lähemalt API dokumentatsiooni. &chalk; pildid koosnevad kihtidest, mida praegu on nelja tüüpi: joonistamiskihid, grupikihid, kohandamiskihid (need sisaldavad filtrit, mis rakendatakse dünaamiliselt kohandamiskihi all asuvatele kihtidele) ja komponendikihid. Filtrid toimivad alati joonistamiskihil. Joonistamiskihid sisaldavad joonistamisseadmeid klassist KisPaintDevice. Joonistamisseade omakorda tagab ligipääsu tegelikele pikslitele. PaintDevice edastatakse üldiselt jagatud viitadesse mähituna. Jagatud viit peab arvet, mitmes kohas joonistamisseadet parajasti kasutatakse ja kustutab joonistamisseadme, kui seda enam kusagil ei kasutata. Joonistamiseadme jagatud viida versiooni tunneb ära sufiksi SP järgi (see on lühend sõnadest shared pointer). Arvesta aga seda, et mitte kunagi ei tohi otseselt kustutada KisPaintDeviceSP. Uurime üht lihtsat filtrit, mis inverteerib piksli. Filtri kood asub kataloogis koffice/chalk/plugins/filters/example. Põhimeetod on KisFilterInvert::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration* /*config*/, const QRect& rect). Funktsioonile edastatakse kaks joonistusseadet, konfiguratsiooniobjekt (mida selles lihtsas filtris ei kasutata) ja rect. rect kirjeldab joonistusseadme ala, millel filter tegutseb. Seda ala kirjeldavad täisarvud, mis tähendab, et pikslisisene täpsus puudub. Joonistusseade src on lugemiseks, dst kirjutamiseks. Need parameetrid võivad tegelikkuses osutada ühele ja samale joonistusseadmele, aga ka erinevatele. (Märkus: võimalik, et tulevikus ongi ainult üks joonistusseade.) Vaatame nüüd koodi rida realt: void KisFilterInvert::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration* /*config*/, const QRect& rect) { Q_ASSERT(src != 0); Q_ASSERT(dst != 0); KisRectIteratorPixel srcIt = src->createRectIterator(rect.x(), rect.y(), rect.width(), rect.height(), false); KisRectIteratorPixel dstIt = dst->createRectIterator(rect.x(), rect.y(), rect.width(), rect.height(), true ); int pixelsProcessed = 0; setProgressTotalSteps(rect.width() * rect.height()); KisColorSpace * cs = src->colorSpace(); Q_INT32 psize = cs->pixelSize(); while( ! srcIt.isDone() ) { if(srcIt.isSelected()) { memcpy(dstIt.rawData(), srcIt.oldRawData(), psize); cs->invertColor( dstIt.rawData(), 1); } setProgress(++pixelsProcessed); ++srcIt; ++dstIt; } setProgressDone(); // Must be called even if you don't really support progression } See loob iteraatori olemasolevate pikslite lugemiseks. Chalkl on kolme tüüpi iteraatoreid: rõhtne, püstine ja ristkülikuline. Viimane ehk rect-iteraator kasutab pildiandmete mõttes kõige tõhusamat viisi, kuid ei taga kuidagi järgmise tagastatava piksli asukohta. See tähendab, et sa ei saa olla kindel, et piksel, mille hangid, asub selle piksli naabruses, mille just said. Rõht- ja püstrea iteraatorid tagavad tagastatavate pikslite asukoha. (2) Loome sihtiteraatori, andes write väärtuseks true. See tähendab, et kui sihtjoonistusseade on väiksem kui ristkülik, mida me kirjutame, suurendatakse seda automaatselt kõigi pikslite sobitamiseks, üle mille me itereerime. Arvesta, et siin võib peituda viga: kui src ja dst ei ole üks ja sama seade, on üsna võimalik, et iteraatorite tagastatavad pikslid ei vasta üksteisele. Iga positsiooni korral iteraatoris võib src näiteks olla asukohas 165,200, samal ajal kui dst on asukohas 20,8 — ja nii võib kopeerimine, mille me allpool sooritame, moonutada pilti... Soovid teada, kui piksel on valitud? See on lihtne — kasuta meetodit isSelected. Kuid valitus ei ole piksli binaaromadus, piksel võib olla poolvalitud, vaevu valitud või peaaegu täielikult valitud. Selle väärtuse võib saada ka iteraatorist. Valikud on tegelikult maskijoonistusseade vahemikuga 0 kuni 255, kus 0 on täiesti valimata ja 255 täielikult valitud. Iteraatoril on kaks meetodit: isSelected() ja selectedNess(). Esimene tagastab TÕENE, kui piksel on mingilgi määral valitud (s.t. maksi väärtus on suurem kui 1), teine tagastab maskiväärtuse. Nagu eespool märgitud, peidab see memcpy endas võimalikku suurt viga... rawData() tagastab piksli aktiivset olekut näitava baidimassiivi, oldRawData() tagastab baidimassiivi nii nagu see oli enne seda, kui me lõime iteraatori. Siiski võime me siin kopeerida vale piksli. Tegelikkuses seda väga sageli ei juhtu, kui just pole juba olemas dst, mis erineb seadmest src. Aga see on õige: selle asemel, et välja selgitada, milline bait esindab millist kanalit, kasutame me funktsiooni, mida pakuvad kõik värviruumid aktiivse piksli teisendamiseks. Värviruumides on hulk pikslioperatsioone, mida saab ära kasutada. See ei ole filtri loomise juures veel kõik. Filtritel on veel kaks olulist komponenti: konfiguratsiooniobjekt ja konfiguratsioonividin. Need kaks toimivad tihedas koostöös. Konfiguratsioonividin loob konfiguratsiooniobjekti, kuid seda võib ka täita juba varem olemas olnud konfiguratsiooniobjekt. Konfiguratsiooniobjektid võivad esitada ennast XML-ina ja neid saab luua XML-ist. See muudabki kohandamiskihid võimalikuks. Iteraatoreid on kolme tüüpi: Rõhtread Püstread Ristkülikiteraatorid Rõht- ja püstreaiteraatoritel on meetod iteraatori liigutamiseks järgmisse ritta või veergu: nextRow() ja nextCol(). Nende kasutamine on märksa kiirem kui uue iteraatori loomine igale reale või veerule. Iteraatorid on &chalk;s lõimekindlad, mii et töö saab jagada mitme lõime vahel. &chalk; tulevastes versioonides on kasutusel meetod supportsThreading(), mis määrab, kas filtrit saab rakendada pildi tükkidele (&ie; kõiki piksleid muudetakse iseseisvalt, mitte aga ei muudeta mingi väärtuse võrra, mis määratakse pildi kõigi pikslite uurimise põhjal), ning selle põhjal jagab filtri täitmise automaatselt lõimedesse. KisFilterConfiguration on struktuur, mida kasutatakse filtri seadistuste salvestamiseks kettale, näiteks kohandamiskihtide korral. Skriptiplugin kasutab omadustekaarti, mis KisFilterConfiguration taustal muudab võimalikuks filtreid skriptida. Filtrid võivad pakkuda kohandatud vidina, mida &chalk; näitab filtrigaleriis, filtri eelvaatluse dialoogis või filtriga joonistamise tööriista tööriistavalikute kaardil. Näide õlimaalifiltri põhjal: class KisOilPaintFilterConfiguration : public KisFilterConfiguration { public: KisOilPaintFilterConfiguration(Q_UINT32 brushSize, Q_UINT32 smooth) : KisFilterConfiguration( "oilpaint", 1 ) { setProperty("brushSize", brushSize); setProperty("smooth", smooth); }; public: inline Q_UINT32 brushSize() { return getInt("brushSize"); }; inline Q_UINT32 smooth() {return getInt("smooth"); }; }; Enamikku filtreid saavad kasutajad kohandada. Võimalik on luua konfiguratsioonividin, mida Chalk kasutab iga kord, kui filtrit kasutatakse. Näide: Õlimaali dialoog Õlimaali dialoog Õlimaali dialoog Pane tähele, et sinu teha on ainult dialoogi vasak külg: ülejäänu eest kannab hoolt &chalk; ise. Seadistustevidinat saab luua kolmel moel: Loo &Qt; Disaineriga vidinabaas ja muuda see oma filtri alamklassiks Kasuta mõnda lihtsat vidinat, mis näitavad mitmeid liugureid täisarvude, reaalarvude või tõeväärtuste loenditega. Need on abiks, kui sinu filtrit saab samamoodi, nagu ülaltoodud pildil nähtavat filtrit, seadistada mitmete täisarvude, reaalarvude või täeväärtustega. Vaata KisMultiIntegerFilterWidget, KisMultiDoubleFilterWidget ja KisMultiBoolFilterWidget API dokumentatsiooni. Kirjuta vidina kood ise. See ei ole küll soovitatav, nii et kui sa seda teed, aga soovid, et sinu filter läheks &chalk; ametlikku väljalaskesse, siis võid oodata, et sul palutakse asendada oma käsitsi kirjutatud vidin &Qt; Disaineri vidinaga. Õlimaalifilter kasutab mitme täisarvuga vidinat: KisFilterConfigWidget * KisOilPaintFilter::createConfigurationWidget(QWidget* parent, KisPaintDeviceSP /*dev*/) { vKisIntegerWidgetParam param; param.push_back( KisIntegerWidgetParam( 1, 5, 1, i18n("Brush size"), "brushSize" ) ); param.push_back( KisIntegerWidgetParam( 10, 255, 30, i18n("Smooth"), "smooth" ) ); return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param ); } KisFilterConfiguration* KisOilPaintFilter::configuration(QWidget* nwidget) { KisMultiIntegerFilterWidget* widget = (KisMultiIntegerFilterWidget*) nwidget; if( widget == 0 ) { return new KisOilPaintFilterConfiguration( 1, 30); } else { return new KisOilPaintFilterConfiguration( widget->valueAt( 0 ), widget->valueAt( 1 ) ); } } std::list<KisFilterConfiguration*> KisOilPaintFilter::listOfExamplesConfiguration(KisPaintDeviceSP ) { std::list<KisFilterConfiguration*> list; list.insert(list.begin(), new KisOilPaintFilterConfiguration( 1, 30)); return list; } Siin on näha, kuidas asi töötab: vektor täidetakse täisarvuliste parameetritega ja luuakse vidin. Meetod configuration() uurib vidinat ja loob õige filtri konfiguratsiooniobjekti, milleks antud juhul on mõistagi KisOilPaintFilterConfiguration. Meetod listOfExamplesConfiguration tagastab loendi näidiskonfiguratsiooniobjektidega filtrigalerii dialoogi jaoks. Filtrite koodi kirjutamise juures on loomulikult veel palju põnevat, aga antud selgituste, API dokumentatsiooni ja ligipääsu varal meie lähtekoodile peaks olema võimalik vähemalt alustada. Vajaduse korral ära kõhkle võtmast ühendust &chalk; arendajatega IRC-s või postiloendis. Tööriistad on näha &chalk; tööriistakastis. See tähendab, et uutele tööriistadele on vaid piiratult ruumi — kaalu hoolikalt, kas sinu eesmärke ei aita täita joonistamisoperatsioon. Tööriistad võivad kasutada hiirt ja klaviatuuri väga mitmel moel, mis joonistamisoperatsioonidele pole jõukohane. Sel põhjusel on näiteks kloonimine tööriist, pihusti aga joonistamisoperatsioon. Ole ettevaatlik staatiliste andmetega oma tööriistas: sinu tööriista uus isend luuakse iga sisendseadme jaoks, olgu see hiir, stiilus, kustutaja, pihusti või mis tahes muu. Tööriistad jagunevad loogilistesse rühmadesse: kujundi joonistamise tööriistad (ring, ristkülik) vabakäejoonistamise tööriistad (pintsel) teisendustööriistad (muudavad kihi geomeetriat) täitmistööriistad (näiteks üleminek) vaatetööriistad (ei muuda piksleid, vaid lõuendi kuvamist, näiteks suurendust) valikutööriistad (muudavad valikumaski) Tööriistaliidest kirjeldab KisTool API dokumentatsioon. On kolm alamklassi KisToolPaint, KisToolNonPaint ja KisToolShape (mis tegelikult on KisToolPaint alamklass), mis annavad KisTool'ile spetsiaalseid omadusi joonistamisülesanneteks (s.t. pikslite muutmiseks), mittejoonistamisülesanneteks ja kujundi joonistamise ülesanneteks. Tööriistal on nagu filtrilgi valikuvidin. Praegu kuvatakse valikuvidinaid dokkakna kaardil. Võimalik, et &chalk; 2.0 ajaks seatakse need ribale peamenüü alla (mis asendab siis tööriistariba), aga praegu tuleb veel vidin luua nii, et see sobiks kaardile. Ka valikuvidina loomiseks on kõige parem mõte kasutada &Qt; Disainerit. Tööriista hea näide on tähetööriist: kis_tool_star.cc Makefile.am tool_star_cursor.png wdg_tool_star.ui kis_tool_star.h Makefile.in tool_star.h chaltdetoolstar.desktop tool_star.cc tool_star.png Nagu näha, läheb vaja kaht pilti: üks kursori ja üks tööriistakasti jaoks. tool_star.cc on lihtsalt plugina laadur, selline nagu eespoolgi nähtud. Põhiasi on aga teostus: KisToolStar::KisToolStar() : KisToolShape(i18n("Star")), m_dragging (false), m_currentImage (0) { setName("tool_star"); setCursor(KisCursor::load("tool_star_cursor.png", 6, 6)); m_innerOuterRatio=40; m_vertices=5; } Konstruktor määrab sisemise nime — mida ei tõlgita — ja ülemklassi väljakutse nähtava nime. Me laadime ka kursoripildi ja määrame mitu muutujat. void KisToolStar::update (KisCanvasSubject *subject) { KisToolShape::update (subject); if (m_subject) m_currentImage = m_subject->currentImg(); } Meetod update() kutsutakse välja tööriista valimisel. See ei ole mitte KisTool, vaid KisCanvasObserver meetod. Lõuendivaatlejad saavad alati märguande, kui vaates midagi muutub, mis on tööriistade puhul väga hea. Järgmised meetodid (buttonPress, move ja buttonRelease) kutsub välja &chalk;, kui sisendseadet (hiir, stiilus, kustutaja) vajutatakse, liigutatakse või vabastatakse. Pane tähele, et liikumissündmuse saab ka siis, kui hiirenuppu ei vajutata. Sündmused ei ole tavapärased &Qt; sündmused, vaid sünteetilised &chalk; sündmused, sest meil on vaja väga sügavatasemelist trikitamist, et sündmusi oleks piisavalt korraliku joone joonistamiseks. Vaikimisi loobuvad sellised tööriistakomplektid nagu &Qt; (ja ka GTK) sündmustest, kui nad on liiga hõivatud nendega tegelemiseks, meie aga soovime neid kõiki. void KisToolStar::buttonPress(KisButtonPressEvent *event) { if (m_currentImage && event->button() == LeftButton) { m_dragging = true; m_dragStart = event->pos(); m_dragEnd = event->pos(); m_vertices = m_optWidget->verticesSpinBox->value(); m_innerOuterRatio = m_optWidget->ratioSpinBox->value(); } } void KisToolStar::move(KisMoveEvent *event) { if (m_dragging) { // erase old lines on canvas draw(m_dragStart, m_dragEnd); // move (alt) or resize star if (event->state() & Qt::AltButton) { KisPoint trans = event->pos() - m_dragEnd; m_dragStart += trans; m_dragEnd += trans; } else { m_dragEnd = event->pos(); } // draw new lines on canvas draw(m_dragStart, m_dragEnd); } } void KisToolStar::buttonRelease(KisButtonReleaseEvent *event) { if (!m_subject || !m_currentImage) return; if (m_dragging && event->button() == LeftButton) { // erase old lines on canvas draw(m_dragStart, m_dragEnd); m_dragging = false; if (m_dragStart == m_dragEnd) return; if (!m_currentImage) return; if (!m_currentImage->activeDevice()) return; KisPaintDeviceSP device = m_currentImage->activeDevice ();; KisPainter painter (device); if (m_currentImage->undo()) painter.beginTransaction (i18n("Star")); painter.setPaintColor(m_subject->fgColor()); painter.setBackgroundColor(m_subject->bgColor()); painter.setFillStyle(fillStyle()); painter.setBrush(m_subject->currentBrush()); painter.setPattern(m_subject->currentPattern()); painter.setOpacity(m_opacity); painter.setCompositeOp(m_compositeOp); KisPaintOp * op = KisPaintOpRegistry::instance()->paintOp(m_subject->currentPaintop(), m_subject->currentPaintopSettings(), &painter); painter.setPaintOp(op); // Painter takes ownership vKisPoint coord = starCoordinates(m_vertices, m_dragStart.x(), m_dragStart.y(), m_dragEnd.x(), m_dragEnd.y()); painter.paintPolygon(coord); device->setDirty( painter.dirtyRect() ); notifyModified(); if (m_currentImage->undo()) { m_currentImage->undoAdapter()->addCommand(painter.endTransaction()); } } } Meetod draw() on KisToolStar sisemine meetod ja joonistab tähe kontuuri. Me kutsume selle välja meetodist move(), et anda kasutajale tagasisidet tähe suuruse ja kuju kohta. Pane tähele, et me kasutame Qt::NotROP rasteroperatsiooni, mis tähendab, et draw() teistkordne väljakutsumine sama algus- ja lõpp-punktiga eelnevalt joonistatud täht kustutatakse. void KisToolStar::draw(const KisPoint& start, const KisPoint& end ) { if (!m_subject || !m_currentImage) return; KisCanvasController *controller = m_subject->canvasController(); KisCanvas *canvas = controller->kiscanvas(); KisCanvasPainter p (canvas); QPen pen(Qt::SolidLine); KisPoint startPos; KisPoint endPos; startPos = controller->windowToView(start); endPos = controller->windowToView(end); p.setRasterOp(Qt::NotROP); vKisPoint points = starCoordinates(m_vertices, startPos.x(), startPos.y(), endPos.x(), endPos.y()); for (uint i = 0; i < points.count() - 1; i++) { p.drawLine(points[i].floorQPoint(), points[i + 1].floorQPoint()); } p.drawLine(points[points.count() - 1].floorQPoint(), points[0].floorQPoint()); p.end (); } Meetod setup() on oluline: sellega luuakse toiming, mis lisatakse tööriistakasti, et kasutaja saaks ka tegelikult tööriista valida. Me omistame ka kiirklahvi. Pane tähele, et siin toimub kerge häkkimine: tuleta meelde, et me loome tööriista isendi igale sisendseadmele. See tähendab ka seda, et me kutsume setup() v'lja iga sisendseadme jaoks ja see tähendab, et sama nimega toiming lisatakse mitu korda toimingute kogusse. Aga kõik tundub töötavat, nii et milleks muretseda? void KisToolStar::setup(TDEActionCollection *collection) { m_action = static_cast<TDERadioAction *>(collection->action(name())); if (m_action == 0) { TDEShortcut shortcut(Qt::Key_Plus); shortcut.append(TDEShortcut(Qt::Key_F9)); m_action = new TDERadioAction(i18n("&Star"), "tool_star", shortcut, this, SLOT(activate()), collection, name()); Q_CHECK_PTR(m_action); m_action->setToolTip(i18n("Draw a star")); m_action->setExclusiveGroup("tools"); m_ownAction = true; } } Meetod starCoordinates() sisaldab veidi keerukat matemaatikat — aga see pole eriti tähtis teema juures, kuidas luua tööriistapluginaid. KisPoint KisToolStar::starCoordinates(int N, double mx, double my, double x, double y) { double R=0, r=0; Q_INT32 n=0; double angle; vKisPoint starCoordinatesArray(2*N); // the radius of the outer edges R=sqrt((x-mx)*(x-mx)+(y-my)*(y-my)); // the radius of the inner edges r=R*m_innerOuterRatio/100.0; // the angle angle=-atan2((x-mx),(y-my)); //set outer edges for(n=0;n<N;n++){ starCoordinatesArray[2*n] = KisPoint(mx+R*cos(n * 2.0 * M_PI / N + angle),my+R*sin(n *2.0 * M_PI / N+angle)); } //set inner edges for(n=0;n<N;n++){ starCoordinatesArray[2*n+1] = KisPoint(mx+r*cos((n + 0.5) * 2.0 * M_PI / N + angle),my+r*sin((n +0.5) * 2.0 * M_PI / N + angle)); } return starCoordinatesArray; } Meetod createOptionWidget() kutsutakse välja valikuvidina loomiseks, mida &chalk; näitab kaardil. Et töööriist on iga sisendseadme iga vaate jaoks, tuleb tööriista olek hoida tööriistas. Seda meetodit kutsutakse välja ainult üks kord: valikuvidin salvestatakse ja hangitakse uuesti järgmine kord, kui tööriist aktiveeritakse. QWidget* KisToolStar::createOptionWidget(QWidget* parent) { QWidget *widget = KisToolShape::createOptionWidget(parent); m_optWidget = new WdgToolStar(widget); Q_CHECK_PTR(m_optWidget); m_optWidget->ratioSpinBox->setValue(m_innerOuterRatio); QGridLayout *optionLayout = new QGridLayout(widget, 1, 1); super::addOptionWidgetLayout(optionLayout); optionLayout->addWidget(m_optWidget, 0, 0); return widget; } Tööriistad on üsna lihtsasti loodavad pluginad. Nende loomiseks tuleb lihtsalt konbimeerida KisTool ja KisCanvasObserver liidesed. Joonistamisoperatsioonid on Chalk ühed kõige innovaatilisemad pluginad (koos värviruumide pluginatega). Joonistamisoperatsioon kirjeldab, kuidas tööriistad muudavad piksleid, mida nad puudutavad. Joonistamisoperatsioonid on näiteks pihusti, pliiats või pintsel. Kuid saab ka — tublisti vaeva nähes — luua joonistamisoperatsioone, mis loevad Corel Painteri XML-pintslikirjeldusi ja kasutavad neid määramaks, kuidas joonistada. Joonistamisoperatsioonid algväärtustatakse, kui joonistamistööriist saab mouseDown sündmuse, ja kustutatakse, kui joonistamistööriist saab mouseUp sündmuse. Vahepeal jälgib joonistamisoperatsioon aga eelnevaid positsioone ja muid andmeid, näiteks survet, kui kasutaja pruugib graafikalauda. Joonistamisoperatsiooni baasoperatsioon on muuta piksleid joonistamistööriista kursori asukohas. Seda saab teha ainult ühe korra või siis taimeri abil lasta joonistamisoperatsiooni sooritada kindla ajavahemiku tagant. Esimene on tulus pliiatsitüüpi joonistamisoperatsioonide korral, teine mõistagi pihustitüüpi joonistamisoperatsioonide puhul. Joonistamisoperatsioonidel võib olla väike konfiguratsioonividin, mis asetatakse tööriistaribale. Sestap vajavad joonistamisoperatsiooni konfiguratsioonividinad vidinate rõhtsat paigutamist, mis ei oleks kõrgem kui tööriistariba nupp. Vastasel korral võtab &chalk; üsna kummalise välimuse. Vaatleme üht lihtsat joonistamisoperatsiooni pluginat, mis siiski ilmutab teatud programmeerimisnippe. Kõigepealt tuleb päisefailis määrata vabrik (factory). See loob joonistamisoperatsiooni, kui aktiivne tööriist seda vajab: public: KisSmearyOpFactory() {} virtual ~KisSmearyOpFactory() {} virtual KisPaintOp * createOp(const KisPaintOpSettings *settings, KisPainter * painter); virtual KisID id() { return KisID("paintSmeary", i18n("Smeary Brush")); } virtual bool userVisible(KisColorSpace * ) { return false; } virtual QString pixmap() { return ""; } }; Vabrik sisaldab ka KisID joonistamisoperatsiooni avaliku ja privaatnimega — kontrolli, et sinu joonistamisoperatsiooni privaatnimi ei kattuks mõne muu joonistamisoperatsiooni omaga! — ja võib vajaduse korral tagastada pikselrastri. &chalk; näitab seejärel pikselrastrit koos nimega, mis aitab joonistamisoperatsiooni visuaalselt tuvastada. Joonistamisoperatsiooni teostus on väga lihtne ja selge: KisSmearyOp::KisSmearyOp(KisPainter * painter) : KisPaintOp(painter) { } KisSmearyOp::~KisSmearyOp() { } void KisSmearyOp::paintAt(const KisPoint &pos, const KisPaintInformation& info) { Meetod paintAt() saab kaks parameetrit: aktiivne asukoht (murdarvuna, mitte täispikslites) ja KisPaintInformation objekt, mis sisaldab survet, X- ja Y-kallet ja liikumisvektorit ning tulevikus vahest muudki teavet. if (!m_painter->device()) return; KisBrush *brush = m_painter->brush(); KisBrush on GIMP-i pintslifaili esindus: see on mask, olgu siis üks või mitme maski seeria. Tegelikult me siin pintslit ei kasuta, völja arvatud tulipunkti määramiseks kursori all. Q_ASSERT(brush); if (!brush) return; if (! brush->canPaintFor(info) ) return; KisPaintDeviceSP device = m_painter->device(); KisColorSpace * colorSpace = device->colorSpace(); KisColor kc = m_painter->paintColor(); kc.convertTo(colorSpace); KisPoint hotSpot = brush->hotSpot(info); KisPoint pt = pos - hotSpot; // Split the coordinates into integer plus fractional parts. The integer // is where the dab will be positioned and the fractional part determines // the sub-pixel positioning. Q_INT32 x, y; double xFraction, yFraction; splitCoordinate(pt.x(), &x, &xFraction); splitCoordinate(pt.y(), &y, &yFraction); KisPaintDeviceSP dab = new KisPaintDevice(colorSpace, "smeary dab"); Q_CHECK_PTR(dab); Me ei muuda joonistusseadme piksleid vahetult, vaid loome väikse joonistusseadme 'dab' ja kombineerime selle aktiivse joonistusseadmega. m_painter->setPressure(info.pressure); Nagu kommentaarid ütlevad, on järgnev kood mõeldud tegeliku dab'i loomiseks. antud juhul joonistame mitu joont. Kui joonistamisoperatsiooniga on ühel pool, sõltuvad joonte pikkus, asukoht ja jämedus survest ning me loome paksult katva õlimaalipintsli. Aga selleks pole mul veel aega olnud. // Compute the position of the tufts. The tufts are arranged in a line // perpendicular to the motion of the brush, i.e, the straight line between // the current position and the previous position. // The tufts are spread out through the pressure KisPoint previousPoint = info.movement.toKisPoint(); KisVector2D brushVector(-previousPoint.y(), previousPoint.x()); KisVector2D currentPointVector = KisVector2D(pos); brushVector.normalize(); KisVector2D vl, vr; for (int i = 0; i < (NUMBER_OF_TUFTS / 2); ++i) { // Compute the positions on the new vector. vl = currentPointVector + i * brushVector; KisPoint pl = vl.toKisPoint(); dab->setPixel(pl.roundX(), pl.roundY(), kc); vr = currentPointVector - i * brushVector; KisPoint pr = vr.toKisPoint(); dab->setPixel(pr.roundX(), pr.roundY(), kc); } vr = vr - vl; vr.normalize(); Lõpuks blt'ime dab'i algupärasele joonistuseadmele ja teatame joonistajale, et me oleme värvinud joonistusseadmel väikse ristküliku. if (m_source->hasSelection()) { m_painter->bltSelection(x - 32, y - 32, m_painter->compositeOp(), dab.data(), m_source->selection(), m_painter->opacity(), x - 32, y -32, 64, 64); } else { m_painter->bitBlt(x - 32, y - 32, m_painter->compositeOp(), dab.data(), m_painter->opacity(), x - 32, y -32, 64, 64); } m_painter->addDirtyRect(QRect(x -32, y -32, 64, 64)); } KisPaintOp * KisSmearyOpFactory::createOp(const KisPaintOpSettings */*settings*/, KisPainter * painter) { KisPaintOp * op = new KisSmearyOp(painter); Q_CHECK_PTR(op); return op; } See ongi kõik: joonistamisoperatsioonid on lihtsad ja lõbusad! Vaatepluginad on üpris veidrad asjad: vaateplugin on tavaline KDE komponent (KPart), mis võib pakkuda kasutajaliidest ja teatud funktsionaalsust. Vaatepluginad on näiteks histogrammi kaart või pööramisdialoog. &chalk; kasutab tavalist &koffice;'i failifiltri arhitektuuri. Selle kohta leidub küll veidi vananenud, aga siiski kasulik tutvustus aadressil . Tõenäoliselt on mõistlik teha koostööd &chalk; meeskonnaga, kui soovid luua failifiltreid, ning koondada ona arendustegevus &koffice;'i filtripuusse. Pane tähele, et filtreid saab testida ka ilma &chalk;t käivitamata, kasutades utiliiti koconverter. Filtritel on kaks poolt: import ja eksport. Tavaliselt on need kaks erinevat pluginat, millel on teatud määral ühine kood. Olulised Makefile.am kirjed on järgmised: service_DATA = 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 Sõltumata sellest, kas lood import- või eksportfiltrit, tuleb nagunii teostada järgmine funktsioon: virtual KoFilter::ConversionStatus convert(const QCString& from, const QCString& to); Seadistused .desktop-failides määravad, millises suunas filter teisendab: Import: X-KDE-Export=application/x-chalk X-KDE-Import=image/x-xcf-gimp X-KDE-Weight=1 X-KDE-Library=libchalkXXXimport ServiceTypes=KOfficeFilter Eksport: X-KDE-Export=image/x-xcf-gimp X-KDE-Import=application/x-chalk ServiceTypes=KOfficeFilter Type=Service X-KDE-Weight=1 X-KDE-Library=libchalkXXXexport Ja muidugi on näites toodud MIME tüüp korralik vihje: soovib äkki keegi XCF-filtri teoks teha? Importfiltri suurim probleem on mõistagi kood, millega lugeda andmeid kettalt. Koodi väljakutsumine on üsna lihtne: Märkus: me peame tõesti leidma lahenduse, kuidas &chalk; hoiab faili avatuna ja loeb ainult neid andmeid, mida vaja, mitte aga ei kopeeri kogu sisu sisemise joonistusseadme esindusele. Aga see tähendab andmehalduri taustaprogrammi, mis tunneb TIFF-faile ja muud sellist ning praegu pole seda teostatud. Oleks ideaalne, kui mõned failifiltrid teostaksid klassi, mille provisoorne nimi võiks olla KisFileDataManager, looksid selle isendi objekt aktiivse failiga ja edastaksid selle KisDoc'ile. Aga &chalk; haldab salvestamist kihtide, mitte dokumendi kaupa, nii et see on päris keeruline. KoFilter::ConversionStatus XXXImport::convert(const QCString&, const QCString& to) { if (to != "application/x-chalk") return KoFilter::BadMimeType; KisDoc * doc = dynamic_cast<KisDoc*>(m_chain -> outputDocument()); KisView * view = static_cast<KisView*>(doc -> views().getFirst()); QString filename = m_chain -> inputFile(); if (!doc) return KoFilter::CreationError; doc -> prepareForImport(); if (!filename.isEmpty()) { KURL url(filename); if (url.isEmpty()) return KoFilter::FileNotFound; KisImageXXXConverter ib(doc, doc -> undoAdapter()); if (view != 0) view -> canvasSubject() -> progressDisplay() -> setSubject(&ib, false, true); switch (ib.buildImage(url)) { case KisImageBuilder_RESULT_UNSUPPORTED: return KoFilter::NotImplemented; break; case KisImageBuilder_RESULT_INVALID_ARG: return KoFilter::BadMimeType; break; case KisImageBuilder_RESULT_NO_URI: case KisImageBuilder_RESULT_NOT_LOCAL: return KoFilter::FileNotFound; break; case KisImageBuilder_RESULT_BAD_FETCH: case KisImageBuilder_RESULT_EMPTY: return KoFilter::ParsingError; break; case KisImageBuilder_RESULT_FAILURE: return KoFilter::InternalError; break; case KisImageBuilder_RESULT_OK: doc -> setCurrentImage( ib.image()); return KoFilter::OK; default: break; } } return KoFilter::StorageCreationError; } See peab olema importfilter, nii et kui seda ei kutsuta välja teisendamiseks &chalk; pildiks, on midagi valesti. Filtriahel on juba loonud meile väljunddokumendi. Me peame saatma selle KisDocM'ile, sest &chalk; dokumendid vajavad erilist kohtlemist. Õigupoolest pole sugugi halb mõte kontrollida, ega saatmise tulemus pole 0, sest kui see on nii, siis import ei õnnestu. Kui me kutsume filtri välja graafilisest kasutajaliidesest, üritame saada vaate. Kui vaade on olemas, üritab teisendamiskood värskendada edenemisriba. Filtril on meile failinimi meie sisendafaili jaoks. KisDoc peab olema impordiks ette valmistatud. Teatud seadistused algväärtustatakse ja tagasivõtmine keelatakse. Vastasel juhul saaks tagasi võtta kihtide lisamise, mida teeb importfilter, ja see annaks väga veidraid tulemusi. Otsustasin teostada tegeliku importkoodi eraldi klassis, mille algväärtustan siin. Kogu koodi võib ka sellesse meetodisse asetada, aga see võib minna veidi segaseks. Importija tagastab olekukoodi, millega saab määrata importfiltri oleku. Veateadete näitamise eest kannab hoolt &koffice;. Kui KisImage loomine õnnestus, määrame dokumendi aktiivse pildi oma uueks pildiks. Seejärel ongi kõik: return KoFilter::OK;.