# KDE arhitektuuri ülevaade

Bernd
Gehrmann

    bernd@kdevelop.org

2001
2002
Bernd Gehrmann
&FDLNotice;

Käesolev käsiraamat annab ülevaate KDE arendusplatvormist

KDE
arhitektuur
arendus
programmeerimine

## Teegistruktuur

### Teegid nimepidi

kdecore

  Teek kdecore on iga KDE rakenduse põhiraamistik. See pakub ligipääsu seadistamissüsteemile, käsurea võimalustele, ikoonide laadimisele ja nende käsitlemisele, mõningaid spetsiaalseid protsessidevahelise kommunikatsiooni võimalusi, failikäsitlust ning rea muid vahendeid.

kdeui

  Teek `kdeui` pakub hulganisti elemente ja standarddialooge, mis Qt-l puuduvad või millel on rohkem võimalusi kui nende Qt analoogidel. Samuti kuulub siia mõningaid elemente, mis on Qt vastavate elementide alamklassid ning kasutaja seisukohalt vaadates KDE töölauaga paremini integreeritud.

kio

  Teek `kio` sisaldab vahendeid asünkroonseks ja võrguläbipaistvusega sisend-väljundoperatsioonideks ning ligipääsu MIME tüüpide käsitlemisele. Samuti pakub see KDE failidialoogi ja selle abiklasse.

kjs

  Teek `kjs` kujutab endast JavaScripti teostust.

khtml

  Teek `khtml` sisaldab KHTML komponenti, HTML lehitsemise elementi, DOM API-t ja parsijat, sealhulgas Java ja JavaScripti liidest.

### Klassid grupiti

Rakenduste tuumikkest - klassid, mida vajab peaaegu iga rakendus.

- #### KApplication

  Initsialiseerib ja juhib KDE rakendust.

- #### KUniqueApplication

  Kontrollib, et korraga töötaks ainult üks rakenduse protsess.

- #### KAboutData

  Sisaldab infokasti infot.

- #### KCmdLineArgs

  Käsurea argumentide töötlemine.

Konfiguratsiooniseadistused - ligipääs KDE hierarhilisele konfiguratsiooniandmebaasile, globaalsetele seadistustele ja rakenduse ressurssidele.

- #### KConfig

  Pakub ligipääsu KDE konfiguratsiooniandmebaasile.

- #### KSimpleConfig

  Ligipääs lihtsatele, mittehierarhilistele konfiguratsioonifailidele.

- #### KDesktopFile

  Ligipääs `.desktop`-failidele.

- #### KGlobalSettings

  Hõlpus ligipääs rakendusest otseselt mittesõltuvatele seadistustele.

Failide ja URL-ide käsitlemine - URL-ide, ajutiste failide jne. dekodeerimine.

- #### KURL

  Esindab ja parsib URL-e.

- #### KTempFile

  Loob ajutistele andmetele unikaalsed failid.

- #### KSaveFile

  Lubab faile automaatselt salvestada.

Protsessidevaheline kommunikatsioon - DCOP abiklassid ja alamprotsesside väljakutsumine.

- #### KProcess

  Kutsub välja ja juhib alamprotsesse.

- #### KShellProcess

  Kutsub alamprotsesse välja shelli vahendusel.

- #### PtyProcess

  Suhtlemine alamprotsessidega pseudoterminali vahendusel.

- #### KIPC

  Lihtne IPC mehhanism (kasutab X11 kliendi teateid).

- #### DCOPClient

  DCOP teated.

- #### KDCOPPropertyProxy

  Proxy klass, mis avaldab Qt omadusi DCOP vahendusel.

- #### KDCOPActionProxy

  Proxy klass, mis avaldab DCOP liidese toimingute jaoks.

Utiliitide klassid - mäluhaldus, regulaaravaldised, stringide käsitlemine, juhunumbrid

- #### KRegExp

  POSIX regulaaravaldiste sobivus.

- #### KStringHandler

  Ekstravagantne liides stringide käsitlemiseks.

- #### KZoneAllocator

  Tõhus mälueraldaja väikeste objektide suurtele gruppidele.

- #### KRandomSequence

  Pseudojuhuarvude generaator.

Klahvikorraldused - klassid, mis aitavad luua kogu töölaual kasutatavaid kiirklahve.

- #### KAccel

  Valik kiirklahve.

- #### KStdAccel

  Hõlpus ligipääs tavalistele kiirklahvidele.

- ####

  Valik süsteemseid kiirklahve.

Pilditöötlus - ikoonide laadimine ja käsitlemine.

- #### KIconLoader

  Laeb ikoonid teemaga ühilduvalt.

- #### KIconTheme

  KIconLoaderi abiklassid.

- #### KPixmap

  Pikselrasterklass laiendatud pseudotoonimisvõimalustega.

- #### KPixmapEffect

  Pikselrasterefektid, näiteks üleminekud ja mustrid.

- #### KPixmapIO

  Kiire teisendus `QImage` -> `QPixMap`.

Lohistamine - värvide ja URL-ide lohistamise objektid.

- #### KURLDrag

  Lohistamisobjekt URL-ide jaoks.

- #### KColorDrag

  Lohistamisobjekt värvide jaoks.

- #### KMultipleDrag

  Lubab konstrueerida lohistamisobjekte mitme muu objekti põhjal.

Automaatne lõpetamine

- #### KCompletion

  Üldine stringide automaatne lõpetamine.

- #### KURLCompletion

  URL-ide automaatne lõpetamine.

- #### KShellCompletion

  Käivitatavate failide automaatne lõpetamine.

Elemendid - elementide klassid nimekirjavaadetele, joonlaudadele, värvivalikule jne.

- #### KListView

  Klassi `QListView` variant, mis tunnistab KDE süsteemseid seadistusi.

- #### KListBox

  Klassi `QListBox` variant, mis tunnistab KDE süsteemseid seadistusi.

- #### KIconView

  Klassi `QIconView` variant, mis tunnistab KDE süsteemseid seadistusi.

- #### KLineEdit

  Klassi `QLineEdit` variant lõpetamise toetusega.

- #### KComboBox

  Klassi `QComboBox` variant lõpetamise toetusega.

- #### KFontCombo

  Liitkast fontide valimiseks.

- #### KColorCombo

  Liitkast värvide valimiseks.

- #### KColorButton

  Nupp värvide valimiseks.

- #### KURLCombo

  Liitkast failinimede ja URL-ide valimiseks.

- #### KURLRequester

  Tekstikast failinimede ja URL-ide valimiseks.

- #### KRuler

  Joonlauaelement.

- #### KAnimWidget

  Animatsioonid.

- #### KNumInput

  Element numbrite sisestamiseks.

- #### KPasswordEdit

  Element parooli sisestamiseks.

Dialoogid - kõigi võimalustega dialoogid faili, värvi ja fondi valimiseks.

- #### KFileDialog

  Failivalimise dialoog.

- #### KColorDialog

  Värvi valimise dialoog.

- #### KFontDialog

  Fondi valimise dialoog.

- #### KIconDialog

  Ikooni valimise dialoog.

- #### KKeyDialog

  Dialoog kiirklahvide redigeerimiseks.

- #### KEditToolBar

  Dialoog tööriistaribade redigeerimiseks.

- #### KTipDialog

  Päeva nõuande dialoog.

- #### KAboutDialog

  Infodialoog.

- #### KLineEditDlg

  Lihtne dialoog teksti sisestamiseks.

- #### KURLRequesterDlg

  Lihtne dialoog URL-ide sisestamiseks.

- #### KMessageBox

  Dialoog vigade ja hoiatuste näitamiseks.

- #### KPasswordDialog

  Dialoog parooli sisestamiseks.

Toimingud ja XML GUI

- #### KAction

  Toimingu abstraktsioon, mida võib lisada menüü- ja tööriistaribale.

- #### KActionCollection

  Valik toiminguid.

- #### KXMLGUIClient

  GUI fragment, mis sisaldab toimingukogu ja DOM puu, mis esindab nende asukohta GUI-s.

- #### KPartManager

  Korraldab XMLGUI klientide aktiveerimist.

Pluginad ja komponendid

- #### KLibrary

  Esindab dünaamiliselt laetavat teeki.

- #### KLibLoader

  Ühisteegi laadimine.

- #### KLibFactory

  Objektipere pluginatena.

- #### KServiceType

  Esindab teenuse tüüpi.

- #### KService

  Esindab teenust.

- #### KMimeType

  Esindab MIME tüüpi.

- #### KServiceTypeProfile

  Kasutaja seadistused MIME tüübi seostele.

- #### KTrader

  Teenuste päring.

## Graafika

### Süvataseme graafika QPainteriga

#### Renderdamine QPainteriga

Qt süvataseme pildiloome tugineb neile X11 ja muude aknasüsteemide võimetele, mille jaoks on olemas Qt pordid. Kuid see ka laiendab neid, teostades täiendavaid võimalusi, näiteks teksti ja pikselrastrite afiinsed transformatsioonid.

Qt 2D joonistamise keskne graafikaklass on . Selle aluseks on . Teostatud on kolm võimalikku joonistamisseadet. esindab elementi ekraanil. esindab printerit ja loob PostScript väljundi. tuvastab joonistamiskäsud ja võib salvestada need kettale ning neid hiljem taasesitada. Joonistamiskäskude võimalik salvestusvorming on W3C standard SVG.

Nii on võimalik renderduskoodi, mida kasutad näitamiseks, pruukida ka trükkimiseks, kusjuures toetatud on samasugused võimalused. Praktikas kasutatakse koodi mõistagi veidi erinevas kontekstis. Elemendi kujutamine tehakse peaaegu eranditult elemendiklassi meetodiga paintEvent().

    void FooWidget::paintEvent()
    {
        QPainter p(this);
        // Setup painter
        // Use painter
    }

Printeri korral tuleb kontrollida, et kasutusel oleks QPrinter::newPage(), mis lõpetab lehekülje ja alustab uut. See ei ole mõistetavalt joonistamiselementide juures kuigi oluline. Trükkimisel oleks mõttekas ka kasutada koordinaatide arvutamiseks seadmemeetrikat.

#### Transformatsioonid

Vaikimisi joonistab QPainter kasutatud seadme loomulikus koordinaatide süsteemis. See tähendab, et kui joonistad horisontaalteljel joone pikkusega 10 ühikut, joonistatakse see ekraanil 10-pikslise pikkusega rõhtjoonena. Kuid QPainter võib rakendada enne kujundite ja kõverate tegelikku renderdamist ka afiinseid transformatsioone. Afiinne transformatsioon seob x- ja y-koordinaadid lineaarselt x' ja y'-ga vastavalt maatriksile

Selle 3x3 maatriksi saab määrata funktsiooniga QPainter::setWorldMatrix() ning selle tüüp on QWMatrix. Tavaliselt on see identsusmaatriks, st. m11 ja m22 on üks ning muud parameetrid null. Põhimõtteliselt on olemas kolm erinevat transformatsioonigruppi:

- ##### Lüke

  See liigutab objekti kõik punktid määratud hulga võrra mingis suunas. Lükkemaatriksi saab välja kutsuda QWMatrixi funktsiooniga m.translate(dx, dy). See vastab maatriksile

- ##### Skaleerimine

  See laiendab või ahendab objekti koordinaate, muutes selle ilma moonutusteta suuremaks või väiksemaks. Skaleerimist saab QWMatrixile rakendada m.scale(sx, sy) väljakutsumisega. See vastab maatriksile

  Määrates ühe parameetritest negatiivseks, saab koordinaatide süsteemi peegeldada.

- ##### Nihe

  Kahe parameetriga koordinaatide süsteemi nihe. Nihke saab rakendada m.shear(sh, sv) väljakutsumisega, sellele vastab maatriks

- ##### Pööramine

  Pöörab objekti. Pööramist saab rakendada m.rotate(nurk) väljakutsumisega. Arvesta, et nurk tuleb anda kraadides, mitte matemaatilise nurgana! Vastav maatriks on

  Pane tähele, et pööramine on ekvivalentne skaleerimise ja nihke kombinatsiooniga.

Nüüd mõned pildid, mis näitavad elementaarsete transformatsioonide mõju meie maskotile:

a) Normaalne | b) Pööratud 30 kraadi | c) Nihe teguriga 0,4 | d) Peegeldatud

Transformatsioone võib kombineerida elementaarmaatrikseid korrutades. Arvesta, et maatriksioperatsioonid ei ole üldiselt kommuteeruvad, mistõttu nende mõju tervikuna sõltub sellest, millises järjekorras neid korrutatakse.

#### Jooneatribuutide määramine

Sirgete, kõverate ja polügoonide piirjoonte renderdamist saab modifitseerida spetsiaalset pliiatsit määrates, mida teeb funktsioon QPainter::setPen(). Selle funktsiooni argument on QPen objekt. Selles salvestatud omadused on stiil, värv, ühendusstiil ja otsastiil.

Pliiatsistiil on loendi Qt::PenStyle liige ning sellel võivad olla järgmised väärtused:

Ühendusstiil on loendi Qt::PenJoinStyle liige. See määrab, kuidas joonistatakse ühenduskoht mitme teineteisega seotud sirgjoone vahel. Sellel võivad olla järgmised väärtused:

a) Nurkühendus | c) Längühendus | b) Ümarühendus

Otsastiil on loendi Qt::PenCapStyle liige ja määrab, kuidas joonistatakse sirgjoonte otsad. Sellel võivad olla järgmised väärtused:

a) Lameots | b) Ruutots | c) Ümarots

#### Täiteatribuutide määramine

Polügoonide, ringjoonte või ristkülikute täitestiili saab muuta spetsiaalse pintsli määramisega funktsiooniga QPainter:.setBrush(). See funktsioon kasutab argumendina QBrush objekti. Pintslit saab konstrueerida neljal moel:

- QBrush::QBrush() - loob pintsli, mis ei täida kujundeid.

- QBrush::QBrush(Pintslistiil) - loob musta pintsli ühega all näidatud vaikemustritest.

- QBrush::QBrush(const QColor &, Pintslistiil) - loob värvilise pintsli ühega all näidatud mustritest.

- QBrush::QBrush(const QColor &, const QPixmap) - loob värvilise pintsli omaloodud mustriga, mis antakse teise parameetrina.

Vaikimisi pintslistiil pärineb loendist Qt::BrushStyle. Toome siin ära pildi kõigi eelnevalt määratud mustritega:

Pintsli käitumist saab veel täpsemalt kohandada funktsiooniga QPainter::setBrushOrigin().

#### Värv

Värvidel on oma osa nii kõverate esitamisel kui kujundite täitmisel. Qt-s esindab värve klass QColor. Qt ei toeta selliseid graafilisi võimalusi, nagu ICC värviprofiilid ja värvikorrektsioon. Värvid konstrueeritakse tavaliselt nende punast, rohelist ja sinist komponenti määratledes, kuna RGB on ka viis, millega esitatakse pikslid monitoril.

Võimalik on küll kasutada ka tooni, küllastust ja väärtust. Selline HSV on kasutusel GTK värvidialoogis, näiteks rakenduses Gimp. Siin vastab toon värviketta nurgale, küllastus aga tähistab vahemaad ketta keskpunktist. Väärtuse saab määrata eraldi liuguriga.

#### Muud seadistused

Tavaliselt asendavad joonistusseadmel joonistades joonistatavad pikslid seal varasemad pikslid. See tähendab, et kui joonistad teatud piirkonna punasega ning hiljem joonistad sama piirkonna sinisega, jääb nähtavaks ainult sinine. Qt graafikamudel ei toeta läbipaistvust, st. joonistatud esiplaani kokkusulamist taustaga. Siiski võib üsna hõlpsasti kombineerida tausta ja esiplaani tõeoperaatorite abil. Meetod QPainter::setRasterOp() määrab kasutatavad operaatorid, mis on pärit loendist RasterOp.

Vaikeväärtus on CopyROP, mis ignoreerib tausta. Teine levinud valik on XorROP. Kui joonistad selle operaatoriga musta joone värvilisele kujutisele, inverteeritakse kaetud ala. Seda efekti on näiteks kasutatud mitmetes pilditöötlusrakendustes pildiosade valimisel niinimetatud "marssivaid sipelgaid" kujutava valikukasti tekitamisel.

#### Graafikaprimitiivide joonistamine

Järgnevalt toome ära QPainteri toetatud elementaarsete graafikaelementide loendi. Enamik neist on olemas mitmes versioonis, mis võivad kasutada erineval hulgal argumente. Näiteks ristkülikuid puudutavad meetodid kasutavad tavaliselt argumendina QRect nelja täisarvu.

- Ühe punkti joonistamine - drawPoint().

- Sirgjoonte joonistamine - drawLine(), drawLineSegments() ja drawPolyLine().

- Ristkülikute joonistamine ja täitmine - drawRect(), drawRoundRect(), fillRect() ja eraseRect().

- Ringjoonte, ellipsite ja nende osade joonistamine ja täitmine - drawEllipse(), drawArc(), drawPie ja drawChord().

- Tavaliste polügoonide joonistamine ja täitmine - drawPolygon().

- Bezier' kõverate joonistamine - drawQuadBezier() [drawCubicBezier Qt versioonis 3.0].

#### Pikselrastrite ja piltide joonistamine

Qt pakub piltide esitamiseks kaht väga erinevat klassi.

QPixmap vastab otseselt X11 pikselrasterobjektidele. Pikselrastrid on serveripoolsed objektid, mis moodsate graafikakaartide korral võivad olla isegi vahetult kaardimällu salvestatud. See muudab pikselrastrite edastamise ekraanile äärmiselt tõhusaks ja kiireks. Pikselrastrid toimivad ka elementide vastena ekraanil - QPixmap on klassi QPaintDevice alamklass, nii et sellega on võimalik kasutada ka QPainterit. Moodsad graafikakaardid üldiselt kiirendavad elementaarseid joonistusoperatsioone. Seepärast on üpris tavaline kasutada pikselrastreid topeltpuhverduseks. See tähendab, et elemendi vahetu joonistamise asemel joonistad ajutise pikselrasterobjekti ja kasutad selle edastamiseks elemendile funktsiooni bitBlt. Keerulisemate asjade puhul aitab see vältida vilkumist.

Seevastu QImage objektid asuvad kliendi poolel. Nende põhiülesanne on pakkuda vahetut juurdepääsu pildi pikslitele. Nii saab neid kasutada pilditöötluseks ning sellisteks asjadeks, nagu laadimine või kettale salvestamine (QPixmapi meetod load() kasutab vaheastmena QImage'it). Teisalt on pildi joonistamine elemendile üsna mahukas operatsioon, sest sellega kaasneb edastamine X serverile, mis võib võtta omajagu aega, eriti kui tegemist on suurte piltidega või kaugserveritega. Sõltuvalt värvisügavusest võib teisendus QImage -> QPixmap nõuda ka pseudotoonimist.

#### Teksti joonistamine

Teksti saab esitada meetodi QPainter::drawText() mõne variandiga. Need joonistavad QStringi kas määratud punktis või määratud ristkülikus, kasutades fonti, mille määrab QPainter::setFont(). Kasutada saab ka parameetrit, mis võtab mõne lipu ORed kombinatsiooni loenditest Qt::AlignmentFlags ja Qt::TextFlags

Alates versioonist 3.0 tegeleb Qt täielikult teksti esitamisega ka paremalt vasakule kirjutatavate keelte puhul.

Täiustatum viis teksti esitamiseks on klass QSimpleRichText. Selle klassi objekte võib konstrueerida tekstiosaga HTML siltide kogumit kasutades, mis pakub üpris palju võimalusi, isegi tabeleid. Tekstistiili saab kohandada QStyleSheet abil (sealt leiab ka siltide dokumentatsiooni). Kui rikkaliku teksti vormingu objekt on konstrueeritud, saab seda renderdada elemendile või muule joonistamisseadmele meetodiga QSimpleRichText::draw().

### Struktureeritud graafika klassi QCanvas abil

QPainter pakub võimsa pildiloomemudeli elementidele ja pikselrastritele joonistamiseks. Kuid vahel võib seda olla üsna tülikas kasutada. Alati, kui element saab joonistamissündmuse, tuleb tal ette võtta QPaintEvent::region() või QPaintEvent::rect() analüüsimine, mis tuleb ümber joonistada. Siis tuleb seadistada QPainter ja joonistada kõik objektid, mis kattuvad antud piirkonnaga. Näiteks olgu vektorgraafikarakendus, mis võimaldab lohistada polügoone, ringjooni ja nende gruppe. Iga kord, kui selliseid objekte kas või veidi liigutatakse, käivitab elemendi hiiresündmuse käitleja joonistamissündmuse nii kogu sellele alale, kus need objektid varem asusid, kui ka alale, kuhu need liigutati. Vajalike ümberjoonistuste leidmine ning nende efektiivne sooritamine võib olla päris keeruline, samuti võib see sattuda konflikti rakenduse lähtekoodi objektorienteeritud struktuuriga.

Alternatiivina sisaldab Qt klassi QCanvas, kuhu saab panna graafilised objektid, näiteks polügoonid, teksti, pikselrastrid. Pakkuda saab ka lisaelemente alamklassiga QCanvasItem või mõne veel spetsialiseerituma alamklassiga. Lõuendit võib ekraanil näidata üks või enam elementi klassist QCanvasView, mis tuleb kasutaja tegevuse käitlemiseks alamklassistada. Qt hoolitseb kõigi vaate objektide ümberjoonistamise ees, olgu selle põhjuseks elemendi nähtavaleilmumine, uute objektide loomine või muutmine või mingi muu põhjus. Topeltpuhverduse kasutamine lubab seda teha tõhusal ja vilkumist vältival viisil.

Lõuendi elemendid võivad üksteisega kattuda. Sellisel juhul sõltub see, milline on näha, z-astmest, mille määrab QCanvasItem::setZ(). Elemente saab muuta nähtavaks või nähtamatuks. Samuti võib lasta tausta joonistada kõigi teiste elementide "taga". Hiiresündmuste seostamiseks objektidega lõuendil on meetod QCanvas::collisions(), mis tagastab antud punktis kattuvate elementide loendi. Toome siin ära ühe lõuendivaate:

Taustal joonistatakse võrku. Lisaks on siin element QCanvasText ning lilla QCanvasPolygon. Liblikas on QCanvasPixmap. Sellel on läbipaistvad alad, mis lubavad näha selle all olevaid elemente.

QCanvas kasutamise juhendi näiteks vaimustavate mängude loomiseks leiab internetist sellel aadressil.

### 3D graafika OpenGL abil

#### Süvataseme liides

Tänapäeval on 3D graafika renderdamise de facto standard OpenGL. Selle spetsifikatsiooni teostusi pakuvad Microsoft Windows, Mac OS X ja XFree86, mis tihti toetavad ka nüüdisaegsete graafikakaartide pakutavaid riistvara kiirendamise võimalusi. OpenGL ise tegeleb ainult renderdamisega konkreetses pildimälu piirkonnas GL konteksti vahendusel ega suhtle mingil määral keskkonna tööriistakomplektiga.

Qt pakub elemendi QGLWidget, mis kapseldab akna sellega seotud GL kontekstiga. Põhimõtteliselt tähendab see selle alamklassistamist ja mõningate meetodite taasteostamist.

- Selle asemel, et taasteostada paintEvent() ja kasutada QPainter'it elemendi sisu joonistamiseks, tühistatakse paintGL() ja kasutatakse stseeni renderdamiseks GL käske. QGLWidget hoolitseb GL konteksti muutmise eest aktiivseks enne seda, kui paintGL() välja kutsutakse, ning hiljem tühjendab selle.

- Enne seda, kui kutsutakse esimest korda välja resizeGL() või paintGL(), kutsutakse korraks välja virtuaalmeetod initializeGL(). Seda saab kasutada objektide esitamise nimekirjade konstrueerimiseks ja mis tahes vajaolevaks initsialiseerimiseks.

- Selle asemel, et resizeEvent() taasteostada, tühistatakse resizeGL(). Seda saab kasutada vaateava sobivaks määramiseks.

- Selle asemel, et kutsuda välja update(), kui stseeni olek on muutunud - kui näiteks animeerid selle taimeriga - , tuleks välja kutsuda updateGL(). See käivitab ümberjoonistamise.

Üldiselt toimib QGLWidget nagu üks element ikka, s.t. et on võimalik hiiresündmusi töödelda nagu tavaliselt, elemendi suurust muuta ja kombineerida seda esitamisel muude elementidega.

Qt sisaldab mõningaid näiteid QGLWidgeti kasutamise kohta oma `demo`s. Õppevahendid leiab siit, rohkem infot ja OpenGL selgitusi aga OpenGL koduleheküljelt.

#### Kõrgtaseme liidesed

OpenGL on 3D graafika joonistamise suhteliselt süvataseme liides. Nii, nagu annab QCanvas programmeerijate käsutusse kõrgtaseme liidese objektide ja nende omaduste käsitlemiseks, nii on olemas kõrgtaseme liidesed ka 3D graafika puhul. Üks menukamaid on Open Inventor. Algselt töötas selle välja SGI, tänapäeval on aga olemas ka vaba tarkvara teostus Coin, mida on täiendatud seda Qt-ga siduva tööriistakomplektiga SoQt.

Open Inventori aluseks on niinimetatud stseen. Stseeni võib hoida kõvakettal salvestatuna spetsiaalsesse vormingusse, mis on lähedane VRML vorminguga. Stseen koosneb objektidest, mida nimetatakse sõlmedeks. Open Inventor pakub omalt poolt arvukalt taaskasutatavaid sõlmi, näiteks kuubid, silindrid ja võrgud, samuti valgusallikad, kaamerad jne. Sõlmi esindavad C++ klassid ning neid võib kombineerida ja alamklassistada.

Open Inventori sissejuhatuse leiab siit (üldiselt võib seda artiklit lugedes mõttes SoXt asemele panna SoQt).

## Kasutajaliides

### Toimingumuster

### Menüüde ja tööriistaribade defineerimine XML-is

#### Sissejuhatus

Toimingumuster lubab küll kapseldada kasutaja käivitatud toimingud objekti, mille saab "torgata" kuhugi menüü- või tööriistaribale, kuid see ei lahenda veel menüü enda konstrueerimise probleemi. Tuleb ju kõik hüpikmenüüd luua C++ koodis ja selgelt lisada sinna toimingud teatud järjekorras, pidades silmas standardtoimingute stiilijuhiseid. Nii on üsna raske lubada kasutajal kohandada menüüsid või muuta kiirklahve oma vajadustele kohasemaks ilma lähtekoodi ennast muutmata.

Selle probleemi lahendab klasside kogum nimetusega `XMLGUI`. Põhimõtteliselt eraldab see toimingud (C++ koodis) nende esinemisest menüü- ja tööriistaribadel (XML koodis). Ilma lähtekoodi muutmata saab menüüsid hõlpsasti kohandada lihtsalt XML faili muutes. Lisaks aitab see tagada, et standardtoimingud (näiteks Fail Ava või Abi Info) esinevad just seal, kus stiilijuhised ette näevad. XMLGUI on eriti oluline moodulprogrammides, kus menüüriba elemendid võivad pärineda erinevatelt pluginatelt või komponentidelt.

KDE tipptaseme akna klass KMainWindow eellane on KXMLGUIClient, mistõttu see toetab automaatselt XMLGUI-d. Kõigi selles loodud toimingute eellane peab olema kliendi `actionCollection()`. `createGUI()` väljakutse loob siis terve menüü- ja tööriistaribade komplekti, mida defineerib rakenduse XML fail (mugavuse mõttes on see sufiksiga `ui.rc`).

#### Näide: KView menüü

Järgnevas võtame näiteks KDE pildivaataja KView. Sellel on `ui.rc` fail nimega `kviewui.rc`, mis on paigaldatud koodijupiga `Makefile.am`

    rcdir = $(kde_datadir)/kview
    rc_DATA = kviewui.rc

See on katke failist `kviewui.rc`. Lihtsuse mõttes näitame ainult menüü Vaade definitsiooni.

    <!DOCTYPE kpartgui>
    <kpartgui name="kview">
      <MenuBar>
        <Menu name="view" >
          <Action name="zoom50" />
          <Action name="zoom100" />
          <Action name="zoom200" />
          <Action name="zoomMaxpect" />
          <Separator/>
          <Action name="fullscreen" />
        </Menu>
      </MenuBar>
    </kpartgui>

Vastav osa C++ keeles kõlab:

    KStdAction::zoomIn    ( this, SLOT(slotZoomIn()), actionCollection() );
      KStdAction::zoomOut   ( this, SLOT(slotZoomOut()), actionCollection() );
      KStdAction::zoom      ( this, SLOT(slotZoom()), actionCollection() );
      new KAction           ( i18n("&Half size"), ALT+Key_0,
                              this, SLOT(slotHalfSize()),
                              actionCollection(), "zoom50" );
      new KAction           ( i18n("&Normal size"), ALT+Key_1,
                              this, SLOT(slotDoubleSize()),
                              actionCollection(), "zoom100" );
      new KAction           ( i18n("&Double size"), ALT+Key_2,
                              this, SLOT(slotDoubleSize()),
                              actionCollection(), "zoom200" );
      new KAction           ( i18n("&Fill Screen"), ALT+Key_3,
                              this, SLOT(slotFillScreen()),
                              actionCollection(), "zoomMaxpect" );
      new KAction           ( i18n("Fullscreen &Mode"), CTRL+SHIFT+Key_F,
                              this, SLOT(slotFullScreen()),
                              actionCollection(), "fullscreen" );

Sellise GUI definitsiooni põhjal loodud menüü Vaade näeb välja niisugune:

XML fail algab dokumenditüübi deklaratsiooniga. Kpartgui DTD leiab kdelibs'i lähtekoodis failis `kdeui/kpartgui.dtd`. Faili väliseim element sisaldab atribuudina rakenduse protsessinime. See võib sisaldada ka versiooninumbrit kujul "version=2". Viimane on kasulik rakenduse uue versiooni korral, kui menüüstruktuuri on muudetud, näiteks lisatud uusi võimalusi. Kui suurendada faili `ui.rc` versiooninumbrit, kontrollib KDE, et faili kohandatud versioonid eemaldataks ja kasutatakse just uut faili.

Järgmine rida `<MenuBar>` sisaldab menüüriba deklaratsiooni. Lisada võib ka suvalise arvu `<ToolBar>` deklaratsioone, kui soovid tööriistaribasid luua. Menüü sisaldab alammenüüd nimega "view". See nimi on juba eelnevalt defineeritud ja nii võibki pildil näha sõna "View" (eestindatud menüüs oleks see "Vaade"). Kui deklareerida oma alammenüü, tuleb nende nimetus vahetult lisada. Nii on rakendusel KView alammenüü "Image" (eestindatult "Pilt"), mis tuleb deklareerida nii:

    <Menu name="image" >
       <text>&amp;Image</text>
       ...
    </Menu>

KDE automake-raamistik võimaldab sellised nimetused automaatselt välja noppida ja panna rakenduse `.po` faili, mida siis tõlkijad saavad tarvitada rakenduse emakeelde panekul. Pane tähele, et kiirklahvi tähis "&" tuleb kirjutada XML-i reeglitele vastavalt "&amp;".

Vaatame uuesti meie näidet. KView menüüs Vaade on mitu kohandamistoimingut: `zoom50`, `zoom100`, `zoom200`, `zoomMaxpect` ja `fullscreen`, mis on deklareeritud elemendiga `<Action>`. Pildil nähtavale eraldusjoonele vastab element `<Separator>`.

Pane tähele, et mõnel elemendil ei ole XML-failis vastet. Need on niinimetatud standardtoimingud, mille loob klass KStdAction. Kui lood mingeid toiminguid oma rakenduses (nagu ülaltoodud C++ näites), lisatakse standardtoimingud automaatselt eelnevalt määratud asukohta, mõnikord kaasnevad nendega ka ikoon ja kiirklahv. Neid asukohti saab tuvastada kdelibs lähtekoodi failis `kdeui/ui_standards.rc`.

#### Näide: Konquerori tööriistaribad

Tööriistaribade puhul vaatame nüüd Konquerori GUI definitsiooni. See katke määratleb asukohariba, mis sisaldab endas URL-ide sisestamise välja.

    <ToolBar name="locationToolBar" fullWidth="true" newline="true" >
      <text>Location Toolbar</text>
      <Action name="clear_location" />
      <Action name="location_label" />
      <Action name="toolbar_url_combo" />
      <Action name="go_url" />
    </ToolBar>

Märkame kohe, et siin on märksa rohkem atribuute kui menüüribal, sealhulgas:

- `fullWidth`: ütleb XMLGUI-le, et tööriistariba laius on võrdne tipptaseme akna laiusega. Kuna see on määratud "vääraks" (false), võtab tööriistariba ainult nii palju ruumi, kui talle parajasti vaja läheb ning samasse ritta võivad mahtuda ka muud tööriistaribad.

- `newline`: on seotud eelmise valikuga. Kui see on "tõene" (true), alustab tööriistariba uut rida, vastasel juhul võib see asetseda samas reas eelmise tööriistaribaga.

- `noEdit`: tavaliselt võib kasutaja tööriistaribasid oma käe järgi kohandada, näiteks Konquerori puhul menüükäsuga Seadistused Tööriistaribade seadistamine. Kui see on nüüd "tõene" (true), siis ei saa tööriistariba muuta. See on oluline sellistele tööriistaribadele, mis täidetakse käivitamise ajal, näiteks Konquerori järjehoidjariba.

- `iconText`: käsib XMLGUI-l näidata toimingu teksti ikooni kõrval. Tavaliselt näidatakse teksti ainult kohtspikrina, kui jätta hiirekursor mõneks hetkeks ikooni kohale seisma. Võimalikud väärtused on "icononly" (näidatakse ainult ikooni), "textonly" (näidatakse ainult teksti), "icontextright" (teksti näidatakse ikoonist paremal pool) ja "icontextbottom" (teksti näidatakse ikooni all).

- `hidden`: kui see on "tõene" (true), ei ole tööriistariba algselt nähtaval ja selle aktiveerimiseks tuleb kasutada mingit menüüelementi.

- `position`: selle atribuudi vaikeväärtus on "top", mis tähendab,. et tööriistariba asub menüüriba all. Paljude tööriistadega rakenduste korral, näiteks graafikarakendused, võib olla mõttekas määrata selle asemel asukohaks "left" (vasakul), "right" (paremal) või "bottom" (all).

#### Dünaamilised menüüd

On ilmne, et XML saab sisaldada ainult kasutajaliidese staatilist kirjeldust. Sageli esineb aga menüüsid, mis käivitamisel muutuvad. Näiteks Konquerori menüü Asukoht sisaldab rea elemente Ava kasutades XXX, kus XXX asemel seisab rakendus, mis võib antud MIME tüübiga faili avada. Dokumendi muutumisel muutub ka nende menüüelementide nimekiri. XMLGUI suudab selliste juhtumitega toime tulla niinimetatud toiminguloenditega. XML-failis deklareeritakse toiminguloend ühe elemendina, kuid see sisaldab mitu toimingut, mis lisatakse menüüsse käivitamisel. Meie toodud näide teostatakse Konquerori XML-failis järgmise deklaratsiooniga:

    <Menu name="file">
      <text>&amp;Location</text>
      ...
      <ActionList name="openwith">
      ...
    </Menu>

Näidatavate toimingute lisamiseks kasutatakse siin funktsiooni `KXMLGUIClient::plugActionList()`, eemaldamiseks aga funktsiooni `KXMLGuiClient::unplugActionList()`. Uuendamisrutiin näeb välja selline:

    void MainWindow::updateOpenWithActions()
    {
        unplugActionList("openwith");
        openWithActions.clear();
        for ( /* iterate over the relevant services */ ) {
            KAction *action = new KAction( ...);
            openWithActions.append(action);
        }
        plugActionList("openwith", openWithActions);
    }

Pane tähele, et erinevalt staatilistest toimingutest ei ole need loodud eellasest toimingukogu baasil ja sestab tuleb sul endal nende kustutamise eest hoolt kanda. Lihtsaim viis selleks on kasutada - nagu ülaltoodud näites - `openWithActions.setAutoDelete(true)`.

#### Kontekstimenüüd

Toodud näidetes oli tegemist ainult peaakna menüüriba ja tööriistaribade loomisega. Sellisel juhul on nende loomise protsess kasutaja eest täielikult peidetud väljakutse `createGUI()` taha (kui sul pole just kohandatud konteinereid). Kuid võib esineda juhtumeid, kus soovid konstrueerida muid konteinereid ja täita need XML-failist võetavate GUI definitsioonidega. Üheks näiteks võivad olla kontekstimenüüd. Kontekstimenüü viida saamiseks tuleb seda küsida kliendi "tehaselt" (factory):

    void MainWindow::popupRequested()
    {
        QWidget *w = factory()->container("context_popup", this);
        QPopupMenu *popup = static_cast<QPopupMenu *>(w);
        popup->exec(QCursor::pos());
    }

Meetod `KXMLGUIFactory::container()` püüab leida XML-failis antud nimega konteinerit. Seega võib definitsioon välja näha näiteks nii:

    ...
    <Menu name="context_popup">
      <Action name="file_add"/>
      <Action name="file_remove"/>
    </Menu>
    ...

### Abivõimaluste pakkumine

Rakenduse muutmine hõlpsasti kasutatavaks ja arusaadavaks tähendab ka mitmesuguste kasutajat abistavate võimaluste pakkumist. Sellel on mitu, omavahel osaliselt vastuolulist eesmärki: ühelt poolt peab see andma vastuse kasutaja küsimusele "Kuidas ma seda teha saan?", teiselt poolt aga aitama kasutajal rakendust tundma õppida ja avastada võimalusi, mille olemasolugi ta varem ei teadnud. Seepärast on oluline tähele panna, et mõlema sihi saavutamiseks on äärmiselt mõttekas pakkuda abi korraga mitmel tasandil:

- Kohtspikrid on pisikesed aknakesed, mis ilmuvad kasutajaliidese elementide juurde, kui jätta hiirekursor mõneks hetkeks elemendil peatuma. Need on eriti tähtsad tööriistaribade puhul, kus ainuüksi ikoon ei pruugi alati piisavalt selgelt vihjata, milleks on mingi nupp mõeldud.

- Võimalus "Mis see on?" sisaldab tavaliselt pikemat ja põhjalikumat seletust elemendi või menüükirje kohta. Samas on selle kasutamine veidi keerulisem. Näiteks dialoogides saab seda esile kutsuda kahel viisil: vajutades Shift F1 või klõpsates küsimärgile tiitliribal (kas küsimärk seal ka asub, sõltub küll tugevasti kasutatavast aknahaldurist). Hiirekursor muutub siis küsimärgiga nooleks ning mingile elemendile klõpsates ilmub väike abiaken. Menüüelementide korral saab võimaluse "Mis see on?" tavaliselt aktiveerida klõpsuga tööriistaribal asuvale noole ja küsimärgiga nupule.

- Selle võimaluse miinuseks on aga asjaolu, et kasutajal pole võimalik ette teada, kas teda huvitava elemendi kohta on selline abi olemas või mitte. Kui nüüd küsimärginupule klõpsata ja elemendi kohta ikkagi mingit abi ei ole, võib see tasapisi tekitada tugevat rahulolematust.

  Tänu Qt ja KDE võimalustele saab aga "Mis see on?`" abiaken sisaldada rikkalikus vormingus (rich text) teksti, see tähendab, võib pakkuda erinevaid fonte, rasvast ja kaldkirja või isegi pilte ja tabeleid.

  "Mis see on?" näide:

- Lõpuks peaks igal rakendusel olema ka oma käsiraamat. Tavaliselt näitab seda KDE abikeskus, mille saab avada menüüst Abi. See tähendab, et avatakse täiesti omaette rakendus, mis viib kasutaja fookuse rakenduselt eemale. Seetõttu tuleks arvestada, et käsiraamatu järele tekib vajadus ennekõike siis, kui kohtspikrid või "Mis see on?" ei suuda kasutajat abistada. Muidugi on käsiraamatu eelis selles, et see ei piirdu kasutajaliidese üksiku ja isoleeritud aspekti seletamisega, vaid tutvustab rakendust tervikuna. KDE käsiraamatud pannakse kirja DocBook märkekeeles.

Programmeerija vaatevinklist pakub Qt abi pakkumiseks välja hõlpsasti kasutatava API. Kohtspikri lisamiseks elemendile tarvita klassi QToolTip.

    QToolTip::add(w, i18n("This widget does something."))

Kui menüü- ja tööriistaribad luua toimingumustreid kasutades, võetakse kohtspikrina kasutatav string konstruktori KAction esimesest argumendist:

    action = new KAction(i18n("&Delete"), "editdelete",
                         SHIFT+Key_Delete, actionCollection(), "del")

Siin on küll ka võimalik anda tekst, mida näidatakse antud menüükirje esiletõstmisel olekuribal:

    action->setStatusText(i18n("Deletes the marked file"))

"Mis see on?" API on äärmiselt sarnane. Dialoogide korral kasuta sellist koodi:

    QWhatsThis::add(w, i18n("<qt>This demonstrates <b>Qt</b>'s"
                            " rich text engine.<ul>"
                            "<li>Foo</li>"
                            "<li>Bar</li>"
                            "</ul></qt>"))

Menüükirjete korral aga

    action->setWhatsThis(i18n("Deletes the marked file"))

KDE abikeskuse väljakutsumine on kapseldatud klassi KApplication. Rakenduse käsiraamatu näitamiseks kasuta

    kapp->invokeHelp()

See avab esimese, sisukorraga lehekülje. Kui soovid lasta näidata ainult kindlat käsiraamatu osa, tuleb funktsioonile `invokeHelp()` anda täiendav argument, mis määrab ankru, kuhu hüpata.

## Komponendid ja teenused

### KDE teenused

#### Mis on KDE teenused?

KDE moodularhitektuuris on mõistel teenus keskne koht. See mõiste ei ole jäigalt seotud mingi konkreetse tehnilise teostusega - teenus võib olla plugin ühisteegi näol või siis programm, mida juhitakse DCOP vahendusel. Oma teenusetüübiga lubab teenus teostada teatud konkreetse API või võimaluse. C++ tähenduses võib teenusetüüpi pidada abstraktseks klassiks ja teenust ennast selle liidese teostuseks.

Sellise eraldamise eelised on ilmsed: teenusetüüpi kasutaval rakendusel pole vajadust teada, kuidas see teostatakse, ta kasutab lihtsalt antud teenusetüübiga seotud API-t. Sel moel võib kasutatavat teenust muuta ilma rakendust kuidagi mõjutamata. Samuti on kasutajal võimalik ise määrata, milliseid teenuseid ta teatud võimaluste jaoks eelistab.

Mõned näited:

- Konqueroris kasutatav HTML renderdusmootor on põimitav komponent, mis teostab teenusetüübid `KParts/ReadOnlyPart` ja `Browser/View`.

- KDevelopis on enamik võimalusi esitatud pluginatena teenusetüübiga `KDevelop/Part`. Käivitamisel laetakse kõik selle tüübiga teenused, mis võimaldab IDE-d väga paindlikult laiendada.

- Ikoonivaates näitab Konqueror (kui see on lubatud) piltide, HTML lehekülgede, PDF- ja tekstifailide pisipilte. Ka seda võimalust on võimalik laiendada. Kui soovid lasta näidata oma teatud MIME tüübiga andmefailide eelvaatluse pilte, tuleb teostada teenus tüübiga `ThumbCreator`.

On ilmne, et teenust ei iseloomusta ainult teenusetüüp, mida ta teostab, vaid ka mõningad omadused. Näiteks ThumbCreator ei teosta mitte ainult C++ klassi tüübiga `ThumbCreator`, vaid sisaldab ka MIME tüüpide loendit, mille puhul eelvaatlust pakkuda. KDevelopi komponentidel on omaduseks programmeerimiskeel, mida nad toetavad. Kui rakendus soovib kasutada teatud teenusetüüpi, võib ta ühtlasi anda teenuse omaduste piirangute loendi. Toodud näite korral küsib KDevelop Java projekti tarbeks pluginaid laadides ainult selliseid pluginaid, mille omaduseks on Java programmeerimiskeel. Sellisteks puhkudeks pakub KDE võimsat ja võimalusterohke päringukeelega CORBA sarnast börsi (trader).

#### Teenusetüüpide defineerimine

Uusi teenusetüüpe lisatakse nende kirjeldust kataloogi `KDEDIR/share/servicetypes` paigaldades. KDE automake-raamistikus saab seda teha sellise `Makefile.am` koodijupiga:

    kde_servicetypesdir_DATA = kdeveloppart.desktop
    EXTRA_DIST = $(kde_servicetypesdir_DATA)

KDevelopi komponendi definitsioon `kdeveloppart.desktop` näeb välja selline:

    [Desktop Entry]
    Type=ServiceType
    X-KDE-ServiceType=KDevelop/Part
    Name=KDevelop Part

    [PropertyDef::X-KDevelop-Scope]
    Type=QString

    [PropertyDef::X-KDevelop-ProgrammingLanguages]
    Type=QStringList

    [PropertyDef::X-KDevelop-Args]
    Type=QString

Lisaks tavapärastele kirjetele on toodud näites näha, kuidas deklareerida teenuse omadusi. Igale omaduse definitsioonile vastab konfiguratsioonifailis grupp `[PropertyDef::name]`. Selles grupid deklareerib kirje `Type` omaduse tüübi. Võimalikud tüübid on kirjas klassis QVariant.

#### Ühisteegi teenuste defineerimine

Teenuste definitsioonid on salvestatud kataloogi `KDEDIR/share/services`:

    kde_servicesdir_DATA = kdevdoxygen.desktop
    EXTRA_DIST = $(kde_servicesdir_DATA)

Järgnev näitefail `kdevdoxygen.desktop` defineerib plugina `KDevDoxygen` tüübiga `KDevelop/Part`:

    [Desktop Entry]
    Type=Service
    Comment=Doxygen
    Name=KDevDoxygen
    ServiceTypes=KDevelop/Part
    X-KDE-Library=libkdevdoxygen
    X-KDevelop-ProgrammingLanguages=C,C++,Java
    X-KDevelop-Scope=Project

Lisaks tavalistele deklaratsioonidele pööra tähelepanu kirjele `X-KDE-Library`. See sisaldab libtool teegi nime (ilma laiendita `.la`). Ühtlasi fikseerib see (eesliitega `init_`) eksporditava sümboli nime teegis, mis tagastab ohbjetipere. Toodud näites peab teek sisaldama järgmist funktsiooni:

    extern "C" {
        void *init_libkdevdoxygen()
        {
            return new DoxygenFactory;
        }
    };

Pere klassi `DoxygenFactory` tüüp sõltub konkreetsest teenusetüübist, mida teenus teostab. Meie KDevelopi plugina näites peab pere olema `KDevFactory` (mille eellane on `KLibFactory`). Levinuimad näide on KParts::Factory, mis peaks anda KParts::ReadOnlyPart või enamikul juhtudel üldisem KLibFactory.

#### Ühisteekide teenuste kasutamine

Ühisteegi teenuse kasutamiseks rakenduses tuleb hakida seda esindav KService objekt. Sellest räägitakse pikemalt MIME tüüpe tutvustavas osas (samuti ikka veel kirjutamata osas KTraderi kohta).

`KService` objekti olemasolul on väga lihtne laadida teek ja hankida viit selle pere objektile:

    KService *service = ...
    QString libName = QFile::encodeName(service->library());
    KLibFactory *factory = KLibLoader::self()->factory(libName);
    if (!factory) {
        QString name = service->name();
        QString errorMessage = KLibLoader::self()->lastErrorMessage();
        KMessageBox::error(0, i18n("There was an error loading service %1.\n"
                                   "The diagnostics from libtool is:\n%2")
                              .arg(name).arg(errorMessage);
    }

Siit edasi sõltub kõik taas teenusetüübist. Tavalise plugina korral tuleb luua objektid meetodiga KLibFactory::create(). KPartsi korral tuleb kogumiviit suunata konkreetsemale KParts::Factory ja kasutada selle create() meetodit:

    if (factory->inherits("KParts::Factory")) {
        KParts::Factory *partFactory = static_cast<KParts::Factory*>(factory);
        QObject *obj = partFactory->createPart(parentWidget, widgetName,
                                               parent, name, "KParts::ReadOnlyPart");
        ...
    } else {
        cout << "Service does not implement the right factory" << endl;
    }

#### DCOP teenuste defineerimine

DCOP teenus on tavaliselt teostatud programmina, mis käivitub vajaduse korral. Sellisel juhul loob ta silmuse ja jälgib DCOP ühendusi. Programm võib olla interaktiivne, kuid see võib ka täielikult või osaliselt tegutseda taustal deemonina, ilma et kasutaja seda otseselt märkaks. Sellise deemoni näide on `kio_uiserver`, mis teostab kasutaja suhtlust, näiteks KIO teegi edenemisdialoogi. Antud kontekstis on tsentraliseeritud deemoni eeliseks näiteks see, et mitme erineva faili tõmbamise edenemist saab näidata ühes aknas isegi juhul, kui tõmbamine käivitati erinevatest rakendustest.

DCOP teenus defineeritakse teisitii kui ühisteegi teenus. Loomulikult ei määra see teeki, vaid käivitatava faili. Samuti ei määra DCOP teenused rida ServiceType, sest tavaliselt käivitatakse nad nimepidi. Lisaomadustena on selles kaks rida:

`X-DCOP-ServiceType` määrab viisi, kuidas teenus käivitatakse. Väärtus `Unique` sedastab, et teenust saab käivitada vaid ühekordsena. See tähendab, et kui proovid teenust käivitada (nt. KApplication::startServiceByName() vahendusel), uurib KDE, kas see on juba registreeritud DCOP-iga ja kasutab töötavat teenust. Kui see ei ole veel registreeritud, käivitab KDE selle ja ootab registreerimist. Nii saab teenusele kohe saata DCOP väljakutseid. Sellisel juhul peab teenus olema teostatud kui KUniqueApplication.

Väärtus `Multi` teatab `X-DCOP-ServiceType` korral, et korraga võib töötada mitu teenust, nii et iga katse teenust käivitada loob uue protsessi. Viimaks võib kasutada ka väärtust `None`. Sellisel juhul ei oodata teenuse käivitamisel registreerimist DCOP-iga.

`X-KDE-StartupNotify` peaks üldjuhul olema määratud vääraks (false). Kui see nii ei ole, näitab tegumiriba programmi käivitumisel käivitusteadet või, kui kasutaja on nii määranud, muutub kursori kuju.

Selline on `kio_uiserver` definitsioon:

    [Desktop Entry]
    Type=Service
    Name=kio_uiserver
    Exec=kio_uiserver
    X-DCOP-ServiceType=Unique
    X-KDE-StartupNotify=false

#### DCOP teenuste kasutamine

DCOP teenus käivitatakse mõne klassi KApplication meetodiga:

    DCOPClient *client = kapp->dcopClient();
    client->attach();
    if (!client->isApplicationRegistered("kio_uiserver")) {
        QString error;
        if (KApplication::startServiceByName("kio_uiserver", QStringList(), &error))
            cout << "Starting kioserver failed with message " << error << endl;
    }
    ...
    QByteArray data, replyData;
    QCString replyType;
    QDataStream arg(data, IO_WriteOnly);
    arg << true;
    if (!client->call("kio_uiserver", "UIServer", "setListMode(bool)",
                      data, replyType, replyData))
        cout << "Call to kio_uiserver failed" << endl;
    ...

Pane tähele, et siin toodud DCOP väljakutse näide kasutab vahetult argumente. Enamasti on mõttekas tarvitada selle asemel dcopidl2cpp genereeritud väljundit, mis on märksa lihtsam ja veakindlam.

Toodud näiteks käivitatakse teenus "nimepidi", s.t. esimene `KApplication::startServiceByName()` argument on nimi, mis on näha töölauafaili real `Name`. Teine võimalus on kasutada funktsiooni `KApplication::startServiceByDesktopName()`, mis võtab argumendiks töölauafaili failinime, s.t. antud juhul `"kio_uiserver.desktop"`.

Kõik väljakutsed kasutavad teise argumendina URL-ide loendit, mis antakse teenusele käsureal. Kolmas argument on viit klassile `QString`. Kui teenuse käivitamine ebaõnnestub, annab see argument tulemuseks tõlgitud veateate.

### MIME tüübid

#### Mis on MIME tüübid?

MIME tüüpe kasutatakse kirjeldamaks failide või andmekogumite sisu tüüpi. Algselt võeti need kasutusele pildi, helifailide jne. saatmiseks e-postitsi (MIME tähendabki "mitmeotstarbelised e-kirja laiendid", inglise keeles "Multipurpose Internet Mail Extensions"). Hiljem hakati neid kasutama ka veebilehitsejas selle määramiseks, kuidas esitada veebiserverilt kasutajale saadetavaid andmeid. Näiteks HTML-leheküljel on MIME tüüp "text/html", PostScript-failil aga "application/postscript". KDE kasutab MIME tüüpe päris paljudes kohtades:

- Konquerori ikoonivaates näitavad faile ikoonid. Igal MIME tüübiga on seotud teatud ikoon, mida siin näidataksegi.

- Klõpsates Konqueroris faili ikoonile või nimele näidatakse faili põimitud vaatajas või avatakse antud faili tüübiga seotud rakendus.

- Mingeid andmeid ühest rakendusest teise (või ka ühe rakenduse sees) lohistades võib sihtkoht aktsepteerida ainult teatud andmetüüpe. Samuti käsitletakse pildiandmeid tekstiandmetest erinevalt.

- Lõikepuhvr andmetel on samuti MIME tüüp. Tavapäraselt suudavad X-i programmid käsitleda ainult pilte või teksti, kuid Qt abil ei ole andmetüübid piiratud.

Toodud näidetest peaks selguma, et MIME käsitlemine on päris keerukas. Esmalt on vaja luua failinimede seosed MIME tüüpidega. KDE astub veel sammukese edasi ja lubab isegi faili sisu MIME tüübiga siduda, kui näiteks failinimi ei peaks kättesaadav olema. Teiseks tuleb MIME tüübid siduda rakenduste või teekidega, mis suudavad teatud tüüpi faili näidata või redigeerida või sellele pisipildi luua.

Andmete või failide MIME tüübi selgitamiseks on mitmeid API-sid. Üldiselt tähendavad nad kõik teatud kompromissi tegemist kiiruse ja usaldusväärsuse vahel. Failitüübi võib leida ainult failinime vaadates (s.t. enamikul juhtudel failinime laiendit uurides). Näiteks `foo.jpg` on tavaliselt "image/jpeg". Kui laiendit ei ole, pole see meetod mõistagi eriti turvaline ja tuleb vaadata faili sisu. See on loomulikult aeglasem, eriti failide korral, mida tuleb HTTP abil kõigepealt alla laadida. Sisupõhine meetod tugineb failile `KDEDIR/share/mimelnk/magic`, mida siinkohal on keerukas pikemalt käsitleda. Kuid üldiselt saab MIME tüübi info süsteemile suhteliselt lihtsalt teatavaks teha `.desktop`-faili paigaldades ning seda kasutatakse agaralt ja tõhusalt kõigis KDE teekides.

#### MIME tüüpide defineerimine

Defineerimine oma uuele programmile foobar tüübi `"application/x-foo"`. Selleks tuleb kirjutada fail `foo.desktop` ja paigaldada see kataloogi `KDEDIR/share/mimelnk/application` (see on tavapärane asukoht, mis distributsiooniti võib siiski erineda). Selleks tuleb failile `Makefile.am` lisada:

    mimedir = $(kde_mimedir)/application
    mime_DATA = foo.desktop
    EXTRA_DIST = $(mime_DATA)

Fail `foo.desktop` peaks välja nägema selline:

    [Desktop Entry]
    Type=MimeType
    MimeType=application/x-foo
    Icon=fooicon
    Patterns=*.foo;
    DefaultApp=foobar
    Comment=Foo Data File
    Comment[et]=Foo andmefail

Kirje `"Comment"` on mõeldud tõlkimiseks. Et `.desktop`-fail määrab ka ikooni, tuleb paigaldada ikoon `fooicon.png`, mis näitab faili näiteks Konqueroris.

KDE teekides on selline tüübidefinitsioon seotud KMimeType protsessiga. Kasuta seda umbes nii, nagu alljärgnevas näites:

    KMimeType::Ptr type = KMimeType::mimeType("application/x-foo");
    cout << "Type:    " << type->name() < endl;
    cout << "Icon:    " << type->icon() < endl;
    cout << "Comment: " << type->icon() < endl;
    QStringList patterns = type->patterns();
    QStringList::ConstIterator it;
    for (it = patterns.begin(); it != patterns.end(); ++it)
      cout << "Pattern: " << (*it) << endl;

#### Andmete MIME tüübi määramine

Kiire meetod failitüübi määramiseks on `KMimeType::findByURL()`. See otsib URL-i stringi ja enamasti määrab tüübi laiendi põhjal. Teatud protokollide (nt. http, man, info) seda aga ei kasutata. Näiteks Perlis kirjutatud veebiserverite CGI skriptidel on sageli laiend `.pl`, mis osutab tüübile `"text/x-perl"`. Samas on serveri edastatud fail hoopis selle skripti väljund, milleks on enamasti HTML. Sellisel juhul tagastab `KMimeType::findByURL()` MIME tüübi `"application/octet-stream"` (kasutatav `KMimeType::defaultMimeType()` vahendusel), mis osutab võimetusele tüüpi tuvastada.

    KMimeType::Ptr type = KMimeType::findByURL("/home/bernd/foobar.jpg");
    if (type->name() == KMimeType::defaultMimeType())
        cout << "Could not find out type" << endl;
    else
        cout << "Type: " << type->name() << endl;

(sellel meetodil on veel mõningaid argumente, kuid need on dokumenteerimata, mistõttu võib nad antud juhul kõrvale jätta)

Sellisel juhul võib olla mõttekam tuvastada MIME tüüp faili sisu, mitte aga faili nime järgi. See on usaldusväärsem, kuid ka aeglasem meetod, sest selleks tuleb lugeda vähemalt osa failist. Seda teeb klass KMimeMagic, mille veakäsitlus on veidi teistsugune:

    KMimeMagicResult *result = KMimeMagic::self()->findFileType("/home/bernd/foobar.jpg");
    if (!result || !result->isValid())
        cout << "Could not find out type" << endl;
    else
        cout << "Type: " << result->mimeType() << endl;

Selle funktsiooni variant võimaldab määrata ka mälutüki tüüpi. Seda kasutab näiteks Kate esiletõstmise režiimi tuvastamiseks:

    QByteArray array;
    ...
    KMimeMagicResult *result = KMimeMagic::self()->findBufferType(array);
    if (!result || !result->isValid())
        cout << "Could not find out type" << endl;
    else
        cout << "Type: " << result->mimeType() << endl;

Mõistagi suudab isegi KMimeMagic määrata failitüüpi ainult kohalike failide sisu põhjal. Võrgufailide jaoks on veel üks võimalus:

    KURL url("http://developer.kde.org/favicon.ico");
    QString type = KIO::NetAccess::mimetype(url);
    if (type == KMimeType::defaultMimeType())
        cout << "Could not find out type" << endl;
    else
        cout << "Type: " << type << endl;

See käivitab KIO töö, laadides alla osa failist ja uurides seda. Arvesta, see funktsioon on tõenäoliselt päris aeglane ja blokeerib programmi töö. Tavaliselt on seda mõtet kasutada ainult siis, kui `KMimeType::findByURL()` tagastab `"application/octet-stream"`.

Kui sa aga ei soovi rakenduse tööd blokeerida, võib ka vahetult käivitada KIO töö ja luua ühendus selle mõningate signaalidega:

    void FooClass::findType()
    {
        KURL url("http://developer.kde.org/favicon.ico");
        KIO::MimetypeJob *job = KIO::mimetype(url);
        connect( job, SIGNAL(result(KIO::Job*)),
                 this, SLOT(mimeResult(KIO::Job*)) );
    }

    void FooClass::mimeResult(KIO::Job *job)
    {
        if (job->error())
            job->showErrorDialog();
        else
            cout << "MIME type: " << ((KIO::MimetypeJob *)job)->mimetype() << endl;
    }

#### MIME tüübi seostamine rakenduse või teenusega

Rakenduse paigaldamisel paigaldab see oma `.desktop`-faili, mis sisaldab loetelu MIME tüüpidest, mida rakendus suudab avada. Ka komponendid, näiteks KParts, teatavad samasugust infot oma `.desktop`-failide vahendusel. Nii on enamasti olemas mitu programmi ja komponenti, mis suudavad antud MIME tüüpi käsitleda. Nende loendi võib leida klassist `KServiceTypeProfile`:

    KService::OfferList offers = KServiceTypeProfile::offers("text/html", "Application");
    KService::OfferList::ConstIterator it;
    for (it = offers.begin(); it != offers.end(); ++it) {
        KService::Ptr service = (*it);
        cout << "Name: " << service->name() << endl;
    }

Selle funktsiooni tagastatav väärtus ongi pakutavate teenuste loend. `KServiceOffer` objekt liidab KService::Ptr eelistuse numbriga. `KServiceTypeProfile::offers()` tagastatav loend on järjestatud vastavalt kasutaja eelistustele. Kasutaja saab seda muuta, kutsudes välja `"keditfiletype text/html"` või valides HTML-faili korral Konquerori kontekstimenüüst kirje Redigeeri failitüüpi.

Toodud näites nõuti rakenduste nimekirja, mis toetaks tüüpi `text/html`. Loend sisaldab muu hulgas HTML redaktoreid, näiteks Quanta. Teise argumendi `"Application"` võib anda ka `"KParts::ReadOnlyPart"`. Sellisel juhul tagastatakse põimitavate komponentide loend, mis suudavad HTML-i esitada, näiteks KHTML.

Enamasti puudub vajadus saada teada kõiki MIME tüübi ja teenuse tüübi kombinatsiooni käsitleda suutvaid teenuseid. Siis sobib kasutada mugavat funktsiooni, mis tagastab ainult kõige eelistatuma teenuse:

    KService::Ptr offer = KServiceTypeProfile::preferredService("text/html", "Application");
    if (offer)
        cout << "Name: " << service->name() << endl;
    else
        cout << "No appropriate service found" << endl;

Keerulisemate päringute jaoks on mõeldud võimas CORBA taoline maakler.

Rakenduse teenuse käivitamiseks mõne URL-iga on kasutatav KRun:

    KURL::List urlList;
    urlList << "http://www.ietf.org/rfc/rfc1341.txt?number=1341";
    urlList << "http://www.ietf.org/rfc/rfc2046.txt?number=2046";
    KRun::run(offer.service(), urlList);

#### Mitmesugust

Selles osas toome ära mõned API-d, mis on teatud määral seotud meie eelneva jutuga.

Ikooni hankimine URL-ile. See uurib URL-i tüüpi ja tagastab sellega seotud ikooni.

    KURL url("ftp://ftp.kde.org/pub/incoming/wibble.c");
    QString icon = KMimeType::iconForURL(url);

URL-i käivitamine. See uurib URL-i tüüpi ja käivitab kasutaja antud tüübi korral eelistatud programmi.

    KURL url("http://dot.kde.org");
    new KRun(url);

### Võrguläbipaistvus

#### Sissejuhatus

Veebiajastul on äärmiselt oluline, et rakendused võiksid kasutada ressursse kõikjal internetis: nad peavad suutma tõmmata faile veebiserverilt, salvestada faile FTP serverile või lugeda veebiserverilt e-posti. Tihtipeale nimetatakse sellist võimet kasutada faile sõltumata nende asukohast võrguläbipaistvuseks.

Minevikus üritati seda saavutada mitmel erineval moel. Eakas NFS failisüsteem proovis teostada võrguläbipaistvust POSIX-i API tasandil. See toimib päris hästi kohalike suletud võrkude korral, kuid jääb jänni ressurssidega, mille kasutamine ei pruugi alati õnnestuda ja ühendus millega võib olla aeglane. Seepärast on oluline asünkroonsus: kui ootad, et veebilehitseja laeks alla mingi saidi, ei pea see blokeerima kasutajaliidest. Samuti ei peaks veebilehekülje renderdamine algama alles siis, kui kätte on saadud kogu lehekülg, vaid käima regulaarselt vastavalt uute andmete saabumisele.

KDE teekides teostab võrguläbipaistvuse KIO API. Selle arhitektuuri keskne mõiste on IO töö. Töö võib faile kopeerida, kustutada vms. Töö käivitamisel tegutseb see taustal ega blokeeri rakendust. Kogu töö tagasiside rakendusele, näiteks andmete edastamine või edenemisinfo, käib läbi integreeritud Qt sündmusesilmuse.

Töötamiseks taustal on mõeldud konkreetseid ülesandeid täitvad IO moodulid. IO moodulid käivitatakse eraldi protsessidena ja nendega suheldakse UNIX-i domeeni pesade vahendusel. Sel moel ei ole vajalik mitmelõimsus ning ebastabiilsed moodulid ei tekita neid kasutava rakenduse krahhi.

Failide asukohti väljendavad tavapäraselt URL-id. KDE puhul aga ei laienda URL-id lihtsalt kättesaadavate failide vahemikku väljapoole kohalikku failisüsteemi, vaid toimivad ka vastupidi, lubades näiteks sirvida pakitud tar-faile. See saavutatakse URL-ide pesastamisega. Nii võib näiteks HTTP-serveril asuva tar-arhiivi failil olla URL

    http://www-com.physik.hu-berlin.de/~bernd/article.tgz#tar:/paper.tex

#### KIO kasutamine

Enamasti luuakse tööd KIO nimeruumis funktsioone välja kutsudes. Need funktsioonid kasutavad argumendina üht või kaht URL-i ja võib-olla vastavalt vajadusele veel mõningaid parameetreid. Kui töö on lõpetatud, väljastatakse signaal `result(KIO::Job*)`. Signaali väljastamise järel kustutab töö iseenda. Toome siin tüüpilise kasutamise näite:

    void FooClass::makeDirectory()
    {
        SimpleJob *job = KIO::mkdir(KURL("file:/home/bernd/kiodir"));
        connect( job, SIGNAL(result(KIO::Job*)),
                 this, SLOT(mkdirResult(KIO::Job*)) );
    }

    void FooClass::mkdirResult(KIO::Job *job)
    {
        if (job->error())
            job->showErrorDialog();
        else
            cout << "mkdir went fine" << endl;
    }

Sõltuvalt töö tüübist võib olla vajalik ühenduse loomine ka muude signaalidega.

Toome siin ülevaate võimalikest funktsioonidest:

KIO::mkdir(const KURL &url, int õigused)

  Loob kataloogi, lisavõimalusena teatud õigustega.

KIO::rmdir(const KURL &url)

  Eemaldab kataloogi.

KIO::chmod(const KURL &url, int õigused)

  Muudab faili õigusi.

KIO::rename(const KURL &src, const KURL &dest, bool overwrite)

  Nimetab faili ümber.

KIO::symlink(const QString &target, const KURL &dest, bool overwrite, bool showProgressInfo)

  Loob nimeviida.

KIO::stat(const KURL &url, bool showProgressInfo)

  Leiab teatud info faili kohta, näiteks suurus, muutmise aeg ja õigused. Info teeb pärast töö lõpetamist teatavaks KIO::StatJob::statResult().

KIO::get(const KURL &url, bool reload, bool showProgressInfo)

  Edastab andmed URL-ilt.

KIO::put(const KURL &url, int õigused, bool overwrite, bool resume, bool showProgressInfo)

  Edastab andmed URL-ile.

KIO::http_post(const KURL &url, const QByteArray &data, bool showProgressInfo)

  Postitab andmed. Spetsiaalselt HTTP jaoks.

KIO::mimetype(const KURL &url, bool showProgressInfo)

  Püüab leida URL-i MIME tüübi. Tüübi teeb pärast töö lõpetamist teatavaks KIO::MimetypeJob::mimetype().

KIO::file_copy(const KURL &src, const KURL &dest, int õigused, bool overwrite, bool resume, bool showProgressInfo)

  Kopeerib ühe faili.

KIO::file_move(const KURL &src, const KURL &dest, int õigused, bool overwrite, bool resume, bool showProgressInfo)

  Nimetab ümber või liigutab ühe faili.

KIO::file_delete(const KURL &url, bool showProgressInfo)

  Kustutab ühe faili.

KIO::listDir(const KURL &url, bool showProgressInfo)

  Loetleb kataloogi sisu. Igal uue kirje tuvastamisel väljastatakse signaal KIO::ListJob::entries().

KIO::listRecursive(const KURL &url, bool showProgressInfo)

  Sarnane funktsiooniga listDir(), kuid rekursiivne.

KIO::copy(const KURL &src, const KURL &dest, bool showProgressInfo)

  Kopeerib faili või kataloogi. Kataloogid kopeeritakse rekursiivselt.

KIO::move(const KURL &src, const KURL &dest, bool showProgressInfo)

  Liigutab või nimetab ümber faili või kataloogi.

KIO::del(const KURL &src, bool shred, bool showProgressInfo)

  Kustutab faili või kataloogi.

#### Kataloogikirjed

Nii töö KIO::stat() kui ka töö KIO::listDir() tagastavad oma tulemused vastavalt tüübina UDSEntry ja UDSEntryList. Viimane on defineeritud kui QValueList<UDSEntry>. UDS tähendab "universaalne kataloogiteenus" (inglise keeles "Universal Directory Service"). Selle taga seisab põhimõte, et kataloogikirje sisaldab ainult seda infot, mida IO moodul suudab pakkuda. Näiteks ei paku http moodul infot kasutamisõiguste või faili omaniku kohta. UDSEntry on UDSAtom-ite loend. Iga aatom pakub teatud konkreetse infoühiku. See koosneb tüübist, mille on salvestanud m_uds, ning sõltuvalt tüübist kas täisarvulisest väärtusest (m_long) või stringilisest väärtusest (m_str).

Praegu on defineeritud järgmised tüübid:

- UDS_SIZE (täisarv) - faili suurus.

- UDS_USER (string) - faili omav kasutaja.

- UDS_GROUP (string) - faili omav grupp.

- UDS_NAME (string) - failinimi.

- UDS_ACCESS (täisarv) - faili kasutamise õigused, nagu need on salvestanud näiteks libc funktsioon stat() väljal st_mode.

- UDS_FILE_TYPE (täisarv) - faili tüüp, nagu selle on salvestanud näiteks stat() väljal st_mode. Seepärast saab selle väärtuse testimiseks kasutada tavalisi libc makrosid, näiteks S-ISDIR. Arvesta, et IO moodulite pakutud andmed vastavad sellele, mida sisaldab stat(), mitte aga lstat(), nii et näiteks nimeviida korral on failitüüp selle faili tüüp, millele viit osutab, mitte aga viit ise.

- UDS_LINK_DEST (string) - nimeviida puhul viidatud faili nimi.

- UDS_MODIFICATION_TIME (täisarv) - aeg (nagu tüübis time_t), millal faili viimati muudeti, nagu selle on salvestanud näiteks stat() väljal st_mtime.

- UDS_ACCESS_TIME (täisarv) - aeg, millal faili viimati kasutati, nagu selle on salvestanud näiteks stat() väljal st_atime.

- UDS_CREATION_TIME (täisarv) - faili loomise aeg, nagu selle on salvestanud näiteks stat() väljal st_ctime.

- UDS_URL (string) - faili URL, kui see ei ole lihtsalt kataloogi URL-i ja failinime ühend.

- UDS_MIME_TYPE (string) - faili MIME tüüp

- UDS_GUESSED_MIME_TYPE (string) - faili MIME tüüp, nagu seda arvab moodul. Erinevus eelmise tüübiga seisneb selles, et siinpakutut ei tohiks võtta usaldusväärsena (sest selle määramine usaldusväärsel meetodil on liiga kulukas). Näiteks klass KRun kontrollib vahetult MIME tüüpi, kui tal ei ole usaldusväärset infot.

Kuigi failiinfo salvestamise viis klassis `UDSEntry` on paindlik ja praktiline IO mooduli seisukohalt vaadates, on see rakenduse programmeerija vaatevinklist korralik segadik. Näiteks faili MIME tüübi tuvastamiseks tuleb ükshaaval läbi uurida kõik aatomid ja kontrollida, kas `m_uds` on ikka `UDS_MIME_TYPE`. Õnneks on olemas API, mida on palju lihtsam kasutada: klass `KFileItem`.

#### Sünkroonne kasutamine

Sageli on KIO asünkroonne API liiga keerukas kasutada, seepärast ei ole ka täieliku asünkroonsuse teostamine esmatähtis. Näiteks programmi korral, mus suudab korraga käsitleda ainult üht dokumenti, ei ole nagunii midagi teha, kui programm parajasti dokumenti alla laeb. Sellistel lihtsatel juhtudel on olemas märksa lihtsam API staatiliste funktsioonide kogumi näol KIO::NetAccess-is. Näiteks faili kopeerimiseks kasuta:

    KURL source, target;
    source = ...;
    target = ...
    KIO::NetAccess::copy(source, target);

See funktsioon tagastab pärast terve kopeerimisprotsessi lõpetamist. Siiski pakub see meetod edenemisdialoogi ja kontrollib, et rakendus töötleb ümberjoonistamissündmusi.

Eriti huvitav funktsioonide kombinatsioon o `download()` koos funktsiooniga `removeTempFile()`. Esimene tõmbab määratud URL-iga faili ja salvestab selle unikaalse nimega ajutise failina. Nimi salvestatakse teise argumendina. Kui tegemist on kohaliku URL-iga, faili alla ei laeta ja teiseks argumendiks määratakse kohaliku faili nimi. Funktsioon `removeTempFile()` kustutab argumendina antud faili, kui see on varasema allalaadimise tulemus. Kui mitte, siis ei tee see midagi. Nii on sellise kombinatsiooni abil väga hea laadida faile alla sõltumata nende asukohast järgmise koodijupiga:

    KURL url;
    url = ...;
    QString tempFile;
    if (KIO::NetAccess::download(url, tempFile) {
        // load the file with the name tempFile
        KIO::NetAccess::removeTempFile(tempFile);
    }

#### Metaandmed

Nagu eespool nägime, on IO tööde liides üpris abstraktne ega võta arvesse infovahetust rakenduse ja IO mooduli vahel, mis on protokollipõhine. Alati selline lähenemine ei sobi. Näiteks võid soovida anda HTTP moodulile teatud parameetrid kontrollimaks puhvri käitumist või saata koos sooviga kimbu küpsiseid. Selleks on sisse toodud metaandmed. Töö loomisel saab seda seadistada metaandmeid lisades. Iga metaandmete ühik sisaldab võtme-väärtuse paari. Näiteks selleks, et HTTP moodul ei laeks veebilehekülge puhvrist, võib kasutada:

    void FooClass::reloadPage()
    {
        KURL url("http://www.kdevelop.org/index.html");
        KIO::TransferJob *job = KIO::get(url, true, false);
        job->addMetaData("cache", "reload");
        ...
    }

Sama meetodit saab kasutada ka teistpidi, s.t. moodulilt rakendusele suunduva suhtlemise korral. Meetod `Job::queryMetaData()` pärib mooduli edastatud võtme väärtust. HTTP mooduli korral võib näiteks olla võti `"modified"`, mis sisaldab (stringi kujul) kuupäeva, millal veebilehekülge viimati muudeti. Toome ka kasutamisnäite:

    void FooClass::printModifiedDate()
    {
        KURL url("http://developer.kde.org/documentation/kde2arch/index.html");
        KIO::TransferJob *job = KIO::get(url, true, false);
        connect( job, SIGNAL(result(KIO::Job*)),
                 this, SLOT(transferResult(KIO::Job*)) );
    }

    void FooClass::transferResult(KIO::Job *job)
    {
        QString mimetype;
        if (job->error())
            job->showErrorDialog();
        else {
            KIO::TransferJob *transferJob = (KIO::TransferJob*) job;
            QString modified = transferJob->queryMetaData("modified");
            cout << "Last modified: " << modified << endl;
    }

#### Ajastamine

KIO API kasutamisel ei ole tavaliselt vajalik pead vaevata IO moodulite käivitamise ja nendega suhtlemise üksikasjade pärast. Kõige tavalisem on käivitada töö teatud parameetritega ja tegelda töö väljastatud signaalidega.

Tagaplaanil on aga kõik palju keerukam. Tööd luues seatakse see järjekorda. Kui rakendus läheb tagasi sündmusesilmusesse, eraldab KIO mooduliprotsessid järjekorras olevatele töödele. Esimese töö korral on kõik lihtne: käivitatakse vajaliku protokolli IO moodul. Kuid pärast töö lõpetamist (näiteks allalaadimist HTTP-serverilt) ei tapeta tööd otsekohe, vaid see lükatakse jõude moodulite puhvrisse ja tapetakse pärast seda, kui see on olnud mingi aja mitteaktiivne (praegu on väärtuseks 3 minutit). Kui saabub uus soov samale protokollile ja masinale, võetakse moodul uuesti kasutusele. Selle ilmne eelis on tõik, et nii saab tunduvalt kärpida sama masina puhul sarnaseid töid ette võttes muidu uute protsesside loomisele ja võib-olla ka autentimisele kuluvaid ressursse ja aega.

Mõistagi on taaskasutamne võimalik ainult siis, kui olemasolev moodul on oma varasema töö juba lõpetanud. Kui uus soov saabub ajal, mil mooduliprotsess veel käib, tuleb käivitada uus protsess. Ülaltoodud API näiteks ei olnud piiratud uute mooduliprotsesside loomine: kui käivitad järjest 20 erineva faili allalaadimise, käivitab KIO 20 mooduliprotsessi. Sellist moodulite omistamist töödele nimetatakse vahetuks omistamiseks. See ei ole aga mitte alati eelistatav viis, sest võib nõuda hulganisti mälu ja koormata tugevasti nii kliendi kui serveri masinat.

Seepärast on olemas ka teine võimalus: töid saab ajastada. Sellisel juhul luuakse protokolli kohta ainult teatud arv (praegu 3) mooduliprotsesse. Kui lood rohkem töid, seatakse need järjekorda ja täidetakse siis, kui mooduliprotsess jääb jõude. See käib nii:

    KURL url("http://developer.kde.org/documentation/kde2arch/index.html");
    KIO::TransferJob *job = KIO::get(url, true, false);
    KIO::Scheduler::scheduleJob(job);

Kolmas võimalus on ühendusepõhine. Näiteks IMAP mooduli korral ei ole erilist mõtet käivitada ühe ja sama serveri puhul mitu protsessi. Nii või teisiti saab korraga toimida ainult üks IMAP ühendus. Sellisel juhul peab rakendus otseselt suhtlema mooduliga, kõrvaldades mooduli teatud ühenduselt ja seejärel omistama kõik tööd, mis käivad üle ühe ühenduse, samale moodulile. Ka selleks sobib suurepäraselt KIO::Scheduler:

    KURL baseUrl("imap://bernd@albert.physik.hu-berlin.de");
    KIO::Slave *slave = KIO::Scheduler::getConnectedSlave(baseUrl);

    KIO::TransferJob *job1 = KIO::get(KURL(baseUrl, "/INBOX;UID=79374"));
    KIO::Scheduler::assignJobToSlave(slave, job1);

    KIO::TransferJob *job2 = KIO::get(KURL(baseUrl, "/INBOX;UID=86793"));
    KIO::Scheduler::assignJobToSlave(slave, job2);

    ...

    KIO::Scheduler::disconnectSlave(slave);

Moodul on mõtet lahti ühendada alles pärast seda, kui kõik sellele omistatud tööd on kindlasti lõpetatud.

#### IO mooduli defineerimine

Siin vaatame nüüd seda, kuidas lisada süsteemile uus IO moodul. Sarnaselt teenustele teeb uue IO mooduli süsteemile teatavaks väikese konfiguratsioonifaili paigaldamine. Järgnev Makefile.am koodijupp paigaldab FTP protokolli:

    protocoldir = $(kde_servicesdir)
    protocol_DATA = ftp.protocol
    EXTRA_DIST = $(mime_DATA)

Faili ftp.protocol sisu on selline:

    [Protocol]
    exec=kio_ftp
    protocol=ftp
    input=none
    output=filesystem
    listing=Name,Type,Size,Date,Access,Owner,Group,Link,
    reading=true
    writing=true
    makedir=true
    deleting=true
    Icon=ftp

Kirje `"protocol"` määrab, millise protokolli eest antud moodul hoolt kannab. `"exec"` on (vastupidi sellele, mida sa vahest naiivselt arvasid) moodulit teostava teegi nimi. Mooduli käivitamisel käivitatakse `"kdeinit"`, mis omakorda laeb antud teegi enda aadressiruumi. Nii võib töötavat moodulit käsitleda praktikas küll omaette protsessina, kuigi tegelikult on see teostatud teegina. Selle eeliseks on asjaolu, et nii saab säästa hulgaliselt mälu ja kahandada käivituslinkurile vajalikku aega.

Praegu ei ole kasutusel read "input" ja "output".

Ülejäänud `.protocol`-faili read määravad ära mooduli omadused. Üldiselt on võimalused, mida moodul peab teostama, palju lihtsamad kui võimalused, mida KIO API rakendustele pakub. Selle põhjuseks on keerukate tööde jagamine mitmeks alamtööks. Näiteks kataloogi sisu näitamiseks rekursiivselt käivitatakse üks töö tippkataloogis. Seejärel käivitatakse iga alamkataloogi sisu leidmiseks uued alamtööd. KIO ajastaja tagab, et korraga ei oleks aktiivsed liiga palju töid. Ka võib KIO näiteks faili kopeerimiseks protokolli korral, mis ei toeta vahetult kopeerimist (näiteks `ftp:`), lugeda lähtefaili ja seejärel kirjutada andmed sihtfaili. Selleks peab `.protocol`-fail tegema teatavaks, milliseid toiminguid antud moodul toetab.

Kuna moodulid laetakse ühisteegina, kuid kujutavad endast autonoomseid programme, erineb nende koodi raamistik mõnevõrra tavalistest ühisteegi pluginatest. Mooduli käivitamiseks välja kutsutav funktsioon kannab nime `kdemain()`. See sooritab teatud initsialiseerimine ning läheb seejärel sündmusesilmusesse ja ootab rakenduse soove. Välja näeb see nii:

    extern "C" { int kdemain(int argc, char **argv); }

    int kdemain(int argc, char **argv)
    {
        KLocale::setMainCatalogue("kdelibs");
        KInstance instance("kio_ftp");
        (void) KGlobal::locale();

        if (argc != 4) {
            fprintf(stderr, "Usage: kio_ftp protocol "
                            "domain-socket1 domain-socket2\n");
            exit(-1);
        }

        FtpSlave slave(argv[2], argv[3]);
        slave.dispatchLoop();
        return 0;
    }

#### IO mooduli teostamine

Moodulid teostatakse `KIO::SlaveBase` alamklassidena (ülaltoodud näites FtpSlave). Nii vastavad `.protocol`-failis loetletud toimingud teatud `KIO::SlaveBase` teatud virtuaalsetele funktsioonidele, mida mooduli teostus peab taasteostama. Toome siin ära võimalike toimingute ja neile vastavate virtuaalsete funktsioonide loendi:

reading - loeb andmed URL-ilt

  void get(const KURL &url)

writing - kirjutab andmed URL-ile ja loob faili, kui seda veel ei ole.

  void put(const KURL &url, int õigused, bool overwrite, bool resume)

moving - nimetab faili ümber.

  void rename(const KURL &src, const KURL &dest, bool overwrite)

deleting - kustutab faili või kataloogi.

  void del(const KURL &url, bool isFile)

listing - tagastab kataloogi sisu.

  void listDir(const KURL &url)

makedir - loob kataloogi.

  void mkdir(const KURL &url, int õigused)

Lisaks on taasteostatavaid funktsioone, mida ei ole ära toodud `.protocol`-failis. Nende tegevuste puhul määrab KIO automaatselt, kas need on toetatud või mitte (s.t vaiketeostus tagastab vea).

Edastab failiinfo, umbes nagu C funktsioon stat().

  void stat(const KURL &url)

Muudab faili kasutamise õigusi.

  void chmod(const KURL &url, int õigused)

Määrab faili MIME tüübi.

  void mimetype(const KURL &url)

Kopeerib faili.

  copy(const KURL &url, const KURL &dest, int õigused, bool overwrite)

Loob nimeviida.

  void symlink(const QString &target, const KURL &dest, bool overwrite)

Kõik teostused peavad lõppema ühga kahest väljakutsest: kui tegevus oli edukas, peavad nad kutsuma välja `finished()`, kui aga tekkis viga, siis tuleb välja kutsuda `error()` koos veakoodiga esimese ja stringiga teise argumendina. Võimalike veakoodide loendi annab KIO::Error. Teine argument on tavaliselt asjakohane URL. Seda kasutab näiteks `KIO::Job::showErrorDialog()` inimestele mõistetava veateate loomisel.

Võrguprotokollidele vastavate moodulite puhul võib huvi pakkuda meetodi `SlaveBase::setHost()` taasteostamine. See kutsutakse välja teatamaks mooduliprotsessile masinat ja porti ning sisselogimiseks vajalikku kasutajanime ja parooli. Üldiselt saab rakenduse saadetud metaandmete päringuks kasutada `SlaveBase::metaData()`. Teatud võtme metaandmete olemasolu kontrollimiseks on mõeldud `SlaveBase::hasMetaData()`.

#### Tagasiside rakendusele

Mooduli teostatud toimingute tulemusel saadud andmed tuleb mingil moel tagastada mooduliprotsessi kasutavale rakendusele:

- `get()` saadab andmebloki. Seda teeb `data()`, mis võtab argumendiks `QByteArray`. Mõistagi ei pea kõiki andmeid korraga saatma. Näiteks suurt faili saates kutsu `data()` välja väiksemate andmeblokkidega, et rakendus suudaks neid töödelda. Kui edastus on lõpetatud, kutsu välja `finished()`.

- `listDir()` edastab kataloogikirjete info. Selleks kutsu `listEntries()` välja argumendiga `KIO::UDSEntryList`. Nagu `data()` puhul, võib ka seda mitu korda välja kutsuda. Kui oled lõpetanud, kutsu välja `listEntry()`, kusjuures teine argument peab olema tõene (true). Samuti võib välja kutsuda `totalSize()`, mis annab vastuseks kataloogikirjete koguarvu, kui see on teada.

- `stat()` edastab failiinfot, näiteks suuruse, MIME tüübi jne. Sellist infot sisaldab `KIO::UDSEntry`, millest tuleb veel juttu. Selliste andmete saatmiseks rakendustele kasuta `statEntry()`.

- `mimetype()` kutsub välja `mimeType()`, andes argumendiks stringi.

- `get()` ja `copy()` pakuvad edenemisinfot. Seda saavutatakse meetoditega `totalSize()`, `processedSize()` ja `speed()`. Kogusuurus ja töödeldud suurus antakse teada baitides, kiirus baitides sekundi kohta.

- Funktsiooniga `setMetaData()` saab saata metaandmete võtme-väärtuse paare.

#### Suhtlemine kasutajaga

Mõnikord on moodulil vaja suhelda kasutajaga: infosõnumid, autentimisdialoogid või kinnituse küsimine faili ülekirjutamisel.

- `infoMessage()` - informatsiooniline tagasiside, näiteks HTTP mooduli sõnum "Andmete tõmbamine aadressilt <masin>", mida sageli näidatakse rakenduse olekuribal. Rakenduse poolelt vastab sellele meetodile signaal `KIO::Job::infoMessage()`.

- `warning()` - näitab hoiatust teatekastis funktsiooniga `KMessageBox::information()`. Kui sama mooduliprotsessi eelmise warning() väljakutse teatekast veel avatud, ei juhtu midagi.

- `messageBox()` - rikkalikum, kui eelmine meetod. Võimaldab avada teatekasti teksti, pealdise ja mõne nupuga. Vaata täpsemalt loendit SlaveBase::MessageBoxType.

- `openPassDlg()` - avab dialoogi kasutajanime ja parooli sisestamiseks.

## Litsents

&underFDL; &underGPL;