# &kommander;i uus parser

Michal
Rudolf

    mrudolf@kdewebdev.org

Eric
Laffoon

    eric@kdewebdev.org

Marek
Laane

    bald@smail.ee

Tõlge eesti keelde
2005-2008
Michal Rudolf
Eric Laffoon
&FDLNotice;

# Uue parseri dokumentatsioon

Uus parser lisati &kommander;isse versioonis 1.2, mis nägi ilmavalgust KDE 3.4 koosseisus. Käesolev dokument pidi algselt kirjeldama kõiki uue parseri omadusi. Nüüd, kus KDE 3.5.9 koosseisus on välja lastud &kommander; 1.3, on uus parser juba vaikimisi kasutusel, välja arvatud peaaknaga (MainWindow) rakenduste puhul, mis luuakse &Qt; Disaineris. Et uus parser on tunduvalt võimekam, ilma vanale parserile omase pesastamise piiranguta ning väga paljude uute omadustega, soovitame tungivalt seda kasutada.

&kommander;ist endast siin juttu ei tule. Kui soovid teada saada, mis on &kommander;, kuidas luua dialooge ja kuidas manipuleerida käitusajal vidinatega, uuri käsiraamatu teisi osi.

## Vana parser

Alljärgnevalt võrdleme kaht parserit. Kuigi me soovitame üldjuhul uut parserit, on ka vana endiselt toetatud ja kasulikki, eriti kui asi puudutab teiste skriptikeelte kasutamist.

### Vana parser

Vana parser oli tegelikult makroparser. Tunnustati ainult stringe, mille alguses seisis @, mida siis parsiti loogiliselt ja laiendati.

    @LineEdit1.setText(@ListBox.selection)

Kõige selle aluseks olev funktsionaalsus (kohalikud muutujad, avaldised,failide manipuleerimine) tuli teha mõnes teises skriptikeeles, näiteks Bash. Ehkki &kommander;i eesmärk on toetada kõiki skriptikeeli, mis on juba praegu teatud määral võimalik, oli vaja kiirest ja natiivset skriptikeelt, mis oleks kindlasti porditav. Vana parseri suurim probleem oli see, et &kommander;i erisid hinnati enne koodi edastamist skriptikeelel, mis muutis võimatuks nende kasutamise silmustes ja tingimustes.

Arendajate meelest ei ole bash kuigi kiire ega uutele kasutajatele mõistetav, vana parser aga oli algselt just bash, mis kutsus välja DCOP-i. Et &kommander; tahab olla programmeerimiskeeltest sõltumatu, tekkis vajadus muudki kui funktsioonid ise teostada.

### Uus parser

Uus parser on täielik parser. See parsib kogu skripti, mitte ainult funktsioone. Et meid huvitab eelkõige graafiline kasutajaliides, mitte aga skriptikeeled ise, tuli teha kompromisse. Seepärast leiad kindlasti, et &kommander;i skriptid suudavad toime tulla kõigi peamiste ülesannetega ning neid on lihtne ja hõlpus kasutada. Kõike sinu loodut koondab endasse Funktsioonisirvija. Funktsioonisirvija mõte on võimaldada &kommander;i uustulnukatest kasutajatel ligi pääseda kõigele, mida vaid vaja. Põhimõtteliselt sarnaneb see mõnevõrra näiteks tabelarvutusrakenduses KSpread kasutatava sirvijaga, mis aitab valida funktsioone ja sisestada neisse vajalikke parameetreid.

Kui soovid ära kasutada mõne teise skriptikeele funktsionaalsust, saab neid kaasa &kommander;i skriptiobjektidesse vastava päisekirjega. Funktsioonisirvija aitab sisestada viited vidinatele. Tuleb lihtsalt meeles pidada, et parser uurib ühe käigu ajal vana parseri funktsioone ja teise käigu ajal sinu skripti. Nii et kui püüad vidinas midagi muuta ja loed seda keset skripti, ei pruugi tulemus olla just selline, nagu ootasid.

    #!/usr/bin/php

Järgnevad on versiooni 1.2 omadused

- kohalikud ja globaalsed muutujad ning assotsiatiivsed massiivid

- arvavaldised

- stringide manipuleerimine

- mitmesugused struktuurikäsud: if, while, for, foreach

- enamik vana parseri funktsioone

- vidinate otsene manipuleerimine

- palju lisafunktsioone

- korralik käivitamisaeg

- parameetrite saamine signaalidelt skripti pesades

Järgnevad on versiooni 1.3 omadused

- parameetrite edastamine ja saamine skripti käivitamise väljakutsetega

- väärtuse tagastamine skriptist

- vidinate loomine lennult

- signaalide ja pesade ühendamine lennult

- muutuja aliase kasutamine vidina nimeks

- lihtsad indekseeritud massiivi funktsioonid

- otsene ligipääs vidinate pesadele

### Uue parseri kasutamine

Uue parseri lubamiseks anna dialoogi omadusele `useInternalParser` property väärtus `tõene`. Samuti saab uue parseri lubada konkreetses skriptis, lisades

    #!kommander

skripti esimesele reale. Pane tähele ka seda, et kui kasutad skriptis mõnda muud skriptikeelt, siis jõustab &kommander; automaatselt vana parseri, et skript ja dialoog ikka korralikult koostööd teeksid.

    #!/bin/bash
    echo @Self.item(0)
    # returns first parameter passed to script
    # echo $returnvalue passes back to calling script

## Uue parseri omadused

### Tüübid

Iga väärtuse tüüp on kas string, täisarv või double. Tüübiteisendus on automaatne ning alati valitakse kõige sobivam tüüp (kui näiteks lisad täisarvule double'i, on tulemuseks double). Kui üks väärtus on string, on ka tulemus string.

Raskustesse võib sattuda arvväärtuse hankimisel vidinast ja sellega matemaatilise tehte sooritamise puhul. Kuna &kommander; kasutab kahe tekstistringi ühendamiseks tehet `+`, võib ta tõlgendada `LineEdit1.text + 2` kui `22`, aga mitte kui `2`. Probleemide vältimiseks uuri osa Stringifunktsioonid.

### Avaldised

Toetatud on järgmised matemaatilised tehted: `+, -, *, mod,` . Enesestmõistetavalt on toetatud ka tavalised sulud.

Toetatud on kõik võrdlused: `<`, `>`, `<=`, `>=`, `==`, `!=`. `!=` asemel võib kasutada ka `<>`. Samuti on toetatud loogilised tehted `and`, `or` ja `not`, samuti nende C ekvivalendid (`&&`, `||`, `!`).

Stringide puhul võib nende liitmiseks kasutada tehet `+`.

Mõned korrektsete avaldiste näited:

    2+3
    -5 * (2 - 13 mod 3)
    "Loendil on " + 12 + "elementi."

### Muutujad

Muutujaid ei ole vaja deklareerida. Kui kasutad muutujat, võetakse seda kui deklareeritut. Muutuja tüüp tuvastatakseautomaatselt, seda võib hiljem muuta.

Toetatud on ka assotsiatiivsed massiivid. Need seostavad stringivõtmed suvalist tüüpi väärtustega. Massiivi deklareerimiseks lisa sellesse lihtsalt mõni element, näiteks: `A["Quanta"] = "Web editor"`. Massiive saab käsitleda ka käsuga foreach ja massiivifunktsioonidega.

Toetatud on kohalikud ja globaalsed muutujad. Globaalsed muutujad on tähistatud alustava alakriipsuga. See tähendab, et `minuMuutuja` on kohalik, aga `_minuMuutuja` globaalne. Sama kehtib massiivide kohta.

    a = 5
    b = 2 * 5 - (a + 1)
    c = "[Item " + b + "]"
    d["MyKey"] = "MyValue"
    d["MyKey2"] = 5

Muutujate kasutamine vidinates on üsna tavapärane. See tuleb kasuks näiteks vidinate silmuste puhul tabelis.

    for i=0 to 10 do
      mycombo = "ComboTable"+i
      createWidget(mycombo, "ComboBox", "Form1")
    end

### Kommentaarid

Kommentaare saab &kommander;is kasutada kahe programmeerimiskeelte traditsioonilise kommentaarivormi kujul. Kes ei ole programmeerimisega tuttavad, heitku pilk allapoole, kus on näha, mida tähendab traditsiooniline vorm. Soovi korral võid alloleva teksti kopeerida ja asetada nupu või dialoogi initsialiseerimisse, et näha, kuidas kommentaarid tegelikult toimivad.

    // this is a comment for one line
    message_info("Hello World") //traditional first program
    // the above comment also ignored - the messagebox is not
    # this is also a comment
    message_info("This message will show")

Järgnev mitmerealine kommentaar ei toimi ja selle kasutamine põhjustab ülejäänud vidina käivitamise nurjumise.

    /*
    Hei, mina siin tahtsin olla üks kommentaarike
    Pärast mind skripti enam edasi ei käivitata
    ÄRA KASUTA SELLISEID KOMMENTAARE KOMMANDERIS!
    */

### Sisseehitatud globaalsed muutujad

&kommander; pakub mitmeid käepäraseid sisseehitatud globaalseid muutujaid.

- `_ARGS` - dialoogile avamisel edastatav argumendistring

- `_ARGCOUNT` - edastatavate argumentide arv. Need hangitakse argumentidest `ARG1` kuni `ARGn`, kus n on edastatavate argumentide koguarv

- `_KDDIR` - kataloog, millest dialoog käivitatakse. &kommander; kasutab vaikimisi sinu kodukataloogi, aga seda võib muidugi muuta. See on kasulik failide salvestamiseks ja lugemiseks &kommander;i failiga.

- `_NAME` - seda ei ole põhjust kasutada, nii et ära siis seda kasuta

- `_PID` - aktiivse dialoogi protsessi ID, põhimõtteliselt sama mis pid. Seda nime ei tasuks oma muutujates kasutada!

- `_VERSION` - see on abiks, kui soovid lasta näidata töötava &kommander;i versiooni

### Argumentide edastamine &kommander;is

Argumente saab edastada skripti parameetritega, signaalide ja pesadega, käsurea parameetritega ja DCOP-iga. Vaatame skripte. Kutsu oma skript välja nii:

    result = ScriptObject1.execute("Hello World")
    debug(result)

Skriptis leiad midagi sellist:

    var = str_upper(Self.Item(0))
    return(var)

Nüüd tagastatakse teatelogis Stderr HELLO WORLD.

Skripti pesaga ühendatud signaali vastuvõtmine käib samamoodi. Self.Item(0) on esimene parameeter jne. Edastatud argumentide arvu hankimiseks on mõeldud ScriptObject.count.

Käserea parameetrid lubavad nii nimega kui ka nimeta argumente. Nimeta argument näeb välja selline:

    kmdr-executor myprog.kmdr 100 red

kus _ARG1 = 100 ja _ARG2 = red. Tühikutega stringide edastamisel argumendina tuleb nad panna jutumärkidesse. Dialoogikäsu kasutamine muudab asjad keerulisemaks, sest kogu argumendistring tuleb edastada tervikuna, mis tähendab selle asetamist jutumärkidesse.

    dialog("mydialog.kmdr", 100+" \"Hello World\"")

See tagastab _ARG1 = 100 ja _ARG2 = Hello World. Ilma jutumärkideta saaksid _ARG2 = Hello ja _ARG3 = World. Nimega parameetrite kasutamine on kenam ja mitte nii segadusseajav.

    dialog("mydialog.kmdr", "xcount=100 xquote=Hello world")

Nüüd saad neid kasutada globaalsete muutujatega _xcount ja _xquote.

DCOP võib olla päris keeruline, mistõttu me soovitame kasutada meie tööriistu DCOP-i lubamiseks &kommander;i võrgudialoogides näiteks funktsioonisirvijaga. Toome näite DCOP-i väljakutse kohta dialoogist, mis on avatud &kommander;i eellasaknast. Kuna ta teab oma eellast, võib ta saata teabe tagasi ajal, mil ta on avatud, ning vabalt kasutada kõiki oma eellase funktsioone, välja arvatud pesad. Loomulikult saab seda teha ka seesmiselt skriptiga, mis kutstutakse välja väliselt, nii et praktikas ei ole sisuliselt mingeid piire.

    dcop("kmdr-executor-"+parentPid, "KommanderIf", "setText(QString,QString)", "StatusBar8", "Hello")

Vaatame seda osade kaupa. Kõigepealt lisame parentPid "kmdr-ececutor-"-ile, sest me ei saa eeldada, et väljakutsuja on &kommander;i aken. Seda võib kasutada Quanta või KSpreadi või millega tahes. Seejärel adresseerime KommanderIf'i, mis on kena ja puhastatud liides lõppkasutajale. Me loodame, et kui KDE lõpuks KDE4 ajal vahetab DCOP-i välja D-Busi vastu, võtab aina enam rakendusi omaks selle kena lõimimist soodustava liidese. Järgmine parameeter "setText(QString,QString)" on oluline, sest see muudab lubatud parameetrid prototüübiks. Vastasel juhul ei suudaks &kommander; väljakutset valideerida. Niisiis ilma DCOP-väljakutse definitsioonita on tulemuseks viga. Ülejäänud on mõistagi edastatavad parameetrid. Me soovitame uurida rakendusi, mis kasutavad `kdcop`'i, kui soovid näha, kuidas see töötab, ning harjutada DCOP-väljakutsetega shellis, kuni omandad õige süntaksi.

## Käsud

Toetatud on mitmesugused struktuurikäsud. Neid võib igati pesastada.

Samuti on olemas kolm erikäsku: `exit`, `break` ja `continue`. Esimene lõpetab skripti täitmise ja pöördub tagasi. Teine väljub aktiivsest plokist (while, for või foreach) ning kolmas väljub aktiivsest sammust, taasalustades silmuse algusest.

### if

Käsul `if` on järgmine süntaks:

`if` tingimus `then` kood `elseif` tingimus `then` kood `else` kood `endif`

Nii `elseif` kui ka `else` on mittekohustuslikud. Tingimus võib olla suvaline avaldis. Kood täidetakse, kui tingimus on tõene. See tähendab:

- nullist erinev täisarvu ja double korral

- mittetühi stringi korral

    if a * 2 > 7 then
       b = 1
    elseif a < 0 then
       b = 2
    elseif
       b = 0
    endif

### while

`while` tingimus `do` kood `end`

Tingimus arvutatakse uuesti iga silmuse täitmise ajal.

    while i < 15 do
      i = i + a
    end

### for

Käsul `for` on järgmine süntaks:

`for` muutuja `=` algväärtus `to` lõppväärtus `step` avaldis `do` kood `end`

Silmus täidetakse alates algväärtusest ja lõpetatakse siis, kui muutuja väärtus on suurem kui lõppväärtus. Kui määratud on `step`, siis igal sammul suurendatakse muutuja väärtust määratud väärtuse, mitte aga `1` võrra.

    foreach i = 1 to 20 step 5 do
      a = a + 2 * i
    end

### foreach

Käsul `foreach` on järgmine süntaks:

`for` muutuja `in` massiiv `do` kood `end`

Silmus täidetakse iga määratud massiivi võtme puhul. Igal sammul omistatakse muutujale massiivi järgmine võti.

    sum = 0
    foreach i in myArray do
      sum = sum + myArray[i]
    end

## Funktsioonid

Uus parser toetab enamikku vana parseri funktsioone, aga lisatud on ka mõned uued funktsioonid.

### Stringifunktsioonid

Stringifunktsioonid on samad, mis vanas parseris, ainult et nende nimedele eelneb `str_`, mitte `@String`.

- `str_length(`string`)` - tagastab stringi pikkuse

- `str_contains(`string`, `tekst`)` - tagastab 1, kui string sisaldab teksti

- `str_find(`string`, `tekst`, `algus`)` - tagastab teksti esimese esinemiskoha stringis; mittekohustuslik algus määrab otsingu alguskoha

- `str_find(`string`, `tekst`, `algus`)` - tagastab teksti viimase esinemiskoha stringis; mittekohustuslik algus määrab otsingu alguskoha

- `str_left(`string`, `arv`)` - tagastab määratud arvu märke alates stringi algusest

- `str_right(`string`, `arv`)` - tagastab määratud arvu märke alates stringi lõpust

- `str_right(`string`, `algus`, `arv`)` - tagastab stringi alamstringi alates algusest, mis sisaldab määratud arvu märke (või kõik kuni stringi lõpuni, kui viimast parameetrit ei ole antud)

- `str_remove(`string`, `tekst`)` - tagastab stringi koos kõigi alamstringidega, mis on võrdsed eemaldatava tekstiga

- `str_replace(`string`, `tekst`, `tekst2`)` - tagastab stringi koos kõigi alamstringidega, mis vastavad tekstile, mis asendatakse tekst2-ga

- `str_lower(`string`)` - tagastab stringi, mis teisendatakse väiketäheliseks

- `str_upper(`string`)` - tagastab stringi, mis teisendatakse suurtäheliseks

- `str_section(`string`, `eraldaja`, `algus`, `lõpp`)` - tagastab alamstringi, mis sisaldab stringi neid osasid, mis on määratud eraldajaga; kui pole määratud lõppu, tagastatakse kogu alguse sektsioon

- `str_args(`string`, `...`)` - tagastab stringi koos `%1`, `%2`, `%3`-ga, mis asendatakse järgnevate parameetritega.

- `str_isnumber(`string`)` - tagastab 1, kui string on korrektne arv

- `str_isempty(`string`)` - tagastab 1, kui string on tühi

- `str_toint(`string`, `default`)` - tagastab täisarvuks teisendatud stringi; kui teisendamine ei ole võimalik, tagastatakse vaikeväärtus (default)

- `str_todouble(`string`, `default`)` - tagastab double'iks teisendatud stringi; kui teisendamine ei ole võimalik, tagastatakse vaikeväärtus (default)

### &kommander;ri funktsioonid

Toetatud on enamik &kommander;i funktsioone; mõned küll (nt. `expr`) on uues parseris iganenud ega ole kasutatavad.

- `debug(`string`, `...`)` - kirjutab kõik parameetrid standardveaväljundisse stderr

- `echo(`string`, `...`)` - kirjutab kõik parameetrid standardväljundisse stdout

- `dcop(`string`, `...`)` - kutsub välja DCOP-funktsiooni

- `exec(`string`, `shell`)` - käivitab välise programmi (kasutades vajaduse korral mittekohustuslikku shelli); blokeerib aktiivse dialoogi täitmise, kuni parameetrina antud programm on töö lõpetanud; tagastab selle programmi väljundi

- `i18n(`string`)` - märgib stringi tõlgitavaks

- `env(`string`)` - tagastab keskkonnamuutuja väärtuse

- `readSetting(`võti`, `default`)` - tagastab määratud võtmega seadistustefaili salvestatud väärtuse; kui sellist väärtust ei ole, tagastatakse vaikeväärtus (default)

- `writeSetting(`võti`, `väärtus`)` - kirjutab võtme ja väärtuse paari seadistustefaili

&kommander; 1.3 uued omadused

- `execBackground(`string`, `shell`)` - käivitab välise programmi (kasutades vajaduse korral mittekohustuslikku shelli) taustal, blokeerimata aktiivset dialoogi; vastupidi eespool kirjeldatud funktsioonile `exec` ei tagasta programmi väljundit

- `return(`value`)` - tagastab väärtuse väljakutsuvale objektile (skript, nupp...)

- `createWidget(`vidinanimi`, `vidinatüüp`, `eellane`)` - loob uue vidina. Seejärel võib selle asetada näiteks tabelisse või tööriistakasti ja muuta `minuvidin.show(true)` abil nähtavaks. Kui asetad uue vidina vormi, pead mõtlema ka paigutusele. &kommander; ei loo paigutusi lennult ega muuda pikslikaupa positsioneerimist (enamasti). See on veidi häiriv isegi C++ arenduse korral. Me soovitame kasutada rühmakasti ja tegelda paigutusega dialoogis, mis võimaldab parima kontrolli asjade käigu üle.

- `connect(`saatja`, `signaal`, `saaja`, `pesa`)` - ühendab vidina signaali vidina pesaga. Uuri ühenduse dialoogi ja vali sarnased vidinad võimaluste selgitamiseks. Kui näiteks signaal näeb välja nagu `execute(const QString&)`, siis peabki just see siin jutumärkides olema.

- `disconnect(`saatja`, `signaal`, `saaja`, `pesa`)` - tühistab eeltoodud ühenduse. Ka siin on oluline täpne süntaks.

- `widgetExists(`vidinanimi`)` - tuletab meelde, et võid kasutada muutuja nime viitena vidinale. Seda võib kasutada näiteks loodud vidinate kasutamisel, et kontrollida nende olemasolu. Olematu vidina väljakutsumine toob enesestmõistetavalt kaasa vea.

### Massiivifunktsioonid

Toetatud on enamik massiivifunktsioone, kuigi mõned (nt. `value`) on uues parseris iganenud ega ole enam kasutatavad. Ainuke erinevus on see, et nende nimele eelne nüüd `array_`, mitte `@Array`.

Parseri piirangute tõttu tuleb massiivi nimi määrata stringina, näiteks `array_count("MinuMassiiv")`.

- `array_clear(`massiiv`)` - eemaldab kõik elemendid massiivist

- `array_count(`massiiv`)` - tagastab elementide arvu massiivis

- `array_keys(`massiiv`)` - tagastab stringi, mis sisaldab massiivi realõpuga (EOL) eraldatud võtmeid; pane tähele, et kui oled importinud massiivi skalaari (võtmed ilma väärtusteta, vt. allpool näidet) &kommander;i abil, ei saa seda kasutada `array_values("minumassiiv")` abil, nagu vahest võisid oletada (sest see tundub ju sisaldavat ainult väärtusi), vaid kasutada tuleb `array_keys("minumassiiv")`. Aga võib-olla on veel parem mõte kasutada allpool kirjeldatud uusi indekseeritud massiive.

- `array_values(`massiiv`)` - tagastab stringi, mis sisaldab massiivi realõpuga (EOL) eraldatud võtmeid

- `array_tostring(`massiiv`)` - tagastab stringi, mis sisaldab kogu massiivi realõpuga (EOL) eraldatud võtme ja väärtuse paaridena (mida ennast eraldab tabeldusmärk)

- `array_fromstring(`massiiv`, `string`)` - loeb massiivi stringist (tavaliselt pakub seda funktsioon `array_tostring`)

- `array_remove(`massiiv`, `võti`)` - eemaldab võtmega võti elemendi massiivist

Toome näite massiivi kasutamisest:

    array_fromstring("myArray", "1\tA\nsecond\tB\n3\tC")
    foreach key in myArray do
      debug("myArray[" + key + "]= " + myArray[key])
    end

See näitab standardveaväljundis stderr järgnevat teksti. Siin on näha, et massiivi elementide järjekorras ei saa kindel olla, sest võtmed on stringid, mitte arvud.

    myArray[1]= A
    myArray[3]= C
    myArray[second]= B

Teine näide võtmeta massiivi kohta:

    array_fromstring("myArray", "A\nB\nC")
    foreach key in myArray do
      debug(key)
    end
    debug("Massiivi elemendid:\n" + array_keys("myArray"))

See annab tulemuseks:

    A
    B
    C
    Massiivi elemendid:
    A
    B
    C

&kommander; 1.3 uued omadused

- `array_indexedFromString(`massiiv`, `string`, `eraldaja`)` - see kompenseerib tõiga, et &kommander;il puuduvad indekseeritud massiivid. See loob massiivi nullipõhise järjestikindeksiga. Massiivinimes ja kõigis stringides, mida ei väljenda muutuja, tuleb kasutada jutumärke. Eraldaja argument ei ole kohustuslik, vaikimisi on selleks "\t" [tabeldusmärk], mida kasutatakse väljade eraldamiseks tabelite, massiivide või detailividinate lugemisel ja kirjutamisel. Pane tähele, et see massiivi indeks ei kehtesta iseenesest mingeid reegleid. Samahästi võiks selle luua silmusega, ainult et nii on mugavam.

- `array_indexedInsertElements(`massiiv`, `võti`, `string`, `eraldaja`)` - see funktsioon on osa indekseeritud massiivide komplektist ning võimaldab lisada elemente massiivi, hooldades samal ajal järjestikut unikaalset indeksit. Määra alustav indeksi võti, tekstistring ja eraldamise viis. Elemendid lisatakse aina kasvava indeksinumbriga.

- `array_indexedRemoveElements(`massiiv`, `alustav võti`, `arv`)` - see võimaldab eemalda elemente indekseeritud massiivist ja vältida indeksis lünki. Määra alustav võti ja lisavõimalusena eemaldatavate elementide arv. Vaikeväärtus on üks. Tulemuseks on ümberindekseeritud massiiv, millest on vajalikud elemendid eemaldatud.

- `array_indexedToString(`massiiv`, `eraldaja`)` - see võimaldab teisendada indekseeritud massiivi taas stringiks, mis on eriti kasulik detailividinate puhul. Kui näiteks näitad andmebaasipäringu tulemust TreeWidget1 kujul, millel on kuus veergu, võid kasutada valitud rea saamiseks `TreeWidget1.selection`. See on eraldatud tabeldusmärkidega ning sa võid vaadata näiteks selle viiendat elementi, kui kasutad `str_section(TreeWidget1.selection, "\t", 4)` (pea meeles, et see on nullipõhine). See on väätuse lugemiseks päris hea, aga kui soovid seda muuta, näed, et see pole veel kõik. Kui oled stringi lõhkunud, saad selle uuesti kokku panna, kui kasutad `val1+"\t"+val2...` Indekseeritud massiivide kasutamisel võid redigeerida viiendat elementi järgmiselt:

      idx = TreeWidget1.currentItem
      array_indexedFromString("z", TreeWidget1.selection)
      z[4] = "new value"
      TreeWidget1.removeItem(idx)
      TreeWidget1.insertItem(array_indexedToString("z"), idx)

  Pane tähele, et selleks tuli lisada ainult kaks lühikest rida! See on andmebaasi kasutamisel väga tulus.

### Failifunktsioonid

Toetatud on kõik failifunktsioonid, ainuke erinevus on see, et nimede ees seisab `file_`, mitte `@File`.

- `file_read(`nimi`)` - tagastab faili nimi sisu

- `file_write(`nimi`, `...`)` - kirjutab kõik argumendid faili nimi

- `file_append(`nimi`, `...`)` - lisab kõik argumendid faili nimi

### Sisendifunktsioonid

Need funktsioonid näitavad mõnda dialoogi, mis võimaldab kasutajal sisestada teatud väärtuse. Vanas parseris oli nende kasutamiseks mõeldud `@Input`. Enamiku funktsioonide puhul on kõik parameetrid mittekohustuslikud, erand on `input_text`, mis nõuab 2 parameetrit, ja `input_value`, mis nõuab 5 parameetrit.

- `input_color(`nimetus`, `default`)` - tagastab värvi #RRGGBB vormingus

- `input_text(`nimetus`, `pealdis`, `default`)` - tagastab kasutaja sisestatud teksti

- `input_value(`nimetus`, `pealdis`, `default`, `min`, `maks`, `samm`)` - tagastab kasutaja sisestatud väärtuse

- `input_directory(`alguskataloog`, `filter`, `nimetus`)` - tagastab kasutaja valitud kataloogi

- `input_openfile(`nimetus`, `pealdis`, `default`)` - tagastab kasutaja sisestatud olemasoleva faili

- `input_savefile(`nimetus`, `pealdis`, `default`)` - tagastab kasutaja sisestatud faili (kui see on olemas, on vajalik kinnitus)

- `input_openfiles(`nimetus`, `pealdis`, `default`)` - tagastab kasutaja sisestatud olemasolevate failide realõppudega (EOL) eraldatud stringi

### Teatefunktsioonid

Need funktsioonid näitavad kasutajale teatud teadet või paluvad kinnitada mõne toimingu. Vanas parseris oli kasutusel `@Message`.

- `message_info(`tekst`, `nimetus`)` - näitab infoteksti

- `message_error(`tekst`, `nimetus`)` - näitab veateksti

- `message_warning(`tekst`, `nimetus`, `nupp1`, `nupp2`, `nupp3`)` - näitab küsimust koos hoiatuse ja kuni kolme nupuga; tagastatakse valitud nuppude arv; kui nuppude nimesid pole määratud, näidatakse nuppe `Yes` ja `No`

- `message_question(`tekst`, `nimetus`, `nupp1`, `nupp2`, `nupp3`)` - näitab küsimust ja kuni kolme nuppu; tagastatakse valitud nuppude arv; kui nuppude nimesid pole määratud, näidatakse nuppe `Yes` ja `No`