Klik en sleep van object van een groep

Concept van klikken en slepen toegepast op objecten in een groep
(vervolg op eenvoudig klik en sleep voorbeeld)

Als je een aantal voorwerpen maakt tijdens de uitvoering van je programma (at runtime), bv knoppen, kan je die daarbij toewijzen aan een “group”, zodat je daarna de leden van die groep, als een soort child-objecten kan aanspreken (zie Group van een control definiëren).

Die “group” kan je ook gebruiken voor het klik en sleep gedrag.
De Gambas-omgeving helpt door een “laatst gebruikte” object/control waarde bij te houden: LAST
Via die weg kan je een “sleutel” doorgeven door die (op voorhand) op te nemen in het extra “Tag” veld van een object.

bv:

PUBLIC grpEtiketten_MouseDrag()
  ...
  IF Mouse.Left
    DEBUG LAST.Tag
  ENDIF
  ...
END

en

PUBLIC grpEtiketten_Drop()
  ...
  ... = Drag.Data
  DEBUG "dropped on" & LAST.Tag
  ...
END

Software bedrijfsurenteller: Runcounter

Handig bij het testen van een applicatie is te weten of ze opgestart is. Handig bij het onderhouden van een applicatie is te weten hoe dikwijls ze gebruikt werd, in dit geval gestart werd.

Je kan die waarde gemakkelijk bijhouden in het standaard verborgen instellingenbestand met “Settings”. De component “Settings” moet aktief zijn (Project, Properties, Components).

Je steekt in je hoofdmodule MMain of scherm FMain een stukje code dat de teller checkt, en verhoogt met 1.

Settings["General/LastLaunch"] = Now()
IF Settings["General/Runcounter"]
  TRY Settings["General/Runcounter"] = Settings["General/Runcounter"]  + 1
ELSE
  Settings["General/Runcounter"] = 1
ENDIF

In een van je About of Info schermen kan je die counter dan weergeven.

TextLabel2.ToolTip = "Runcounter " & Settings["General/Runcounter"]
TextLabel2.ToolTip &= "; " & Settings["General/LastLaunch", ""] 
TextLabel2.ToolTip &= " - " & Settings["General/LastShutdown", ""]

Bij het debuggen is het ook handig te kijken of het programma normaal opgestart / normaal gesloten is, vandaar de LastLaunch en LastShutdown ‘timestamps’, de shutdown in de code voor het sluiten van het hoofdvenster:

PUBLIC SUB doClose()
  
  Settings["General/LastShutdown"] = Now()
  ME.Close
  
END

Wachtwoorden gebruiken

Er zijn 3 veel voorkomende soorten situaties ivm wachtwoorden:

  1. checken of iemand toegang krijgt adhv zijn wachtwoord.
  2. toegang geven tot gegevens die met een wachtwoord versleuteld zijn.
  3. toegang verkrijgen tot een dienst door een wachtwoord op te sturen bij het inloggen.

1. Check inkomende toegang
De eerste situatie is het gemakkelijkst op te lossen: de gebruiker heeft een toepassing draaien, waarmee hij wil gebruik maken van een dienst.

Je zou die toepassing het wachtwoord kunnen laten controleren, en daarop toegang geven. Maar dan moet je het wachtwoord van die gebruiker sturen. Dat is dus slecht: je stuurt een wachtwoord onnodig over het netwerk, en je hebt blindelings vertrouwen in de “client” applicatie die dat vraagt. Die client-applicatie kan vals zijn (en zo een wachtwoord opvragen van een gebruiker). Bewaak nooit een poort door als ze buiten kloppen, te roepen “Is het wachtwoord Schild en Vriend?”, en te openen als ze “ja” antwoorden.

Het nuttige van dit voorbeeld is dat je het moet omdraaien:

De client stuurt de server of de basisapplicatie het wachtwoord, en daar beslis je dan of het juist is of niet, en of er toegang gegeven wordt.
De waarschijnlijk meest voorkomende encryptie-manier is MD5. Het gebruik ervan betekent dat je bij het maken van het wachtwoord, dat omrekent naar een MD5-waarde. Die MD5-waarde sla je op.
Als een gebruiker inlogt, geeft hij het wachtwoord, dat alleen maar gebruikt wordt om een MD5 waarde van te berekenen; als die overeenkomt met de opgeslagen waarde is het ok. Voordeel is dat op het moment van het geven van het wachtwoord, dat niet opgeslagen hoeft te worden.

Voorbeeld met MD5 met prefix (salt):

Zet de Project, Properties, Components gb.crypt aan

DIM s AS String
s = Crypt.MD5(InputBox("Set administration password: ", "New installation - set password"), "SpecialP")

De prefix “SpecialP” moet je ook zo mogelijk voor bv meer gebruikers verschillend maken. Je moet die wel bij de hand hebben om een vergelijkings-md5 te maken!

Maar op het netwerk sniffen wordt zo niet vermeden. Dus ideaal zou zijn om het doorsturen van het wachtwoord tussen client en server ook te versleutelen, zodat iemand die het netwerk afluistert, daar ook geen toegang toe krijgt.

2. ….

3…..

Component in Gambas2

Basis-uitleg:

  • hoe componenten in Gambas werken
  • hoe ze zelf te maken
  • hoe ze te installeren.

De originele documentatie over componenten vermeldt uitdrukkelijk dat alle “onderstaande tekst” voor Gambas3 is, dus ik doorloop het even in en voor Gambas2:

Componenten

De componenten die je in de Gambas IDE ziet (project, properties), zijn mee geïnstalleerd met de Gambas IDE. (Kijk in je Linux pakket manager om bij te installeren).

In bv OpenSUSE vind je ze na installatie in: /usr/lib64/gambas2/
Bv de gb.chart.component en gb.chart.gambas

De .component is een tekstbestand, en bevat voor gb.chart:

[Component]
Key=gb.chart
State=2
Authors=Fabien Bodard
Needs=Form
Requires=gb.form

en voor gb.settings:

[Component]
Key=gb.settings
Authors=Benoît Minisini

In de IDE zijn de componenten uit te kiezen bij de projecteigenschappen, en tonen bovenstaande zich als:

gb.chart
Chart drawing (Beta version)
Authors: Fabien Bodard
Requires: Graphical form management, gb.form.

en

gb.settings
Application settings managament
Authors: Benoit Minisini

Bij het gebruik van Settings in je broncode worden volgende methodes en eigenschappen zichtbaar in de editor:

De broncode, van bv Settings, vind je na het afhalen en uitpakken van de broncode:
gambas2-2.23.1/comp/src/gb.settings

Een uittreksel (… is overgeslagen code):

' Gambas class file
'
EXPORT
CREATE STATIC
'
CLASS Window
'
STATIC PROPERTY READ Path AS String
'
PRIVATE $sPath AS String
PRIVATE $sTitle AS String
PRIVATE $cSlot AS Collection
PRIVATE $bModify AS Boolean
'
PRIVATE SUB Load()
'  
  DIM hFile AS File
  DIM iLine AS Integer
  DIM sLine AS String
  DIM sSlot AS String
  DIM iPos AS Integer
'
  $cSlot = NEW Collection
  IF NOT Exist($sPath) THEN RETURN
' ...
PUBLIC SUB _new(OPTIONAL Path AS String, OPTIONAL Title AS String)
'
  DIM sDir AS String
  DIM sPath AS String
  DIM sElt AS String
'
  IF Left(Path) <> "/" THEN 
    IF NOT Path THEN
' ...
PUBLIC SUB _free()
'
  TRY ME.Save
'
END
'
PUBLIC SUB Save()
'
  DIM aKey AS NEW String[]
  DIM cSlot AS Collection
  DIM sKey AS String
  DIM hFile AS File
  DIM vVal AS Variant
'
  IF NOT $bModify THEN RETURN
' ....
PRIVATE FUNCTION GetSlot(sKey AS String) AS String
' ...
PUBLIC FUNCTION _get(Key AS String, OPTIONAL {Default} AS Variant) AS Variant
' ...
PUBLIC SUB _put(Value AS Variant, Key AS String)
' ...
PUBLIC SUB Clear(ParentKey AS String)
' ...
PUBLIC SUB Read(hObject AS Object, OPTIONAL sKey AS String, OPTIONAL vDefault AS Variant)
  '
  DIM sVal AS String
  DIM aVal AS String[]
  '
  IF Object.Is(hObject, "Window") THEN
    sKey = Object.Type(hObject) &/ sKey
    LoadWindow(hObject, sKey)
  ELSE
    IF NOT sKey THEN TRY sKey = hObject.Name
    sKey = GetTopLevel(hObject) &/ sKey
    'DEBUG sKey
    TRY hObject.Settings = ME[sKey, vDefault]
  ENDIF
  '
END
'
PUBLIC SUB Write(hObject AS Object, OPTIONAL sKey AS String)
  '
  IF Object.Is(hObject, "Window") THEN
    sKey = Object.Type(hObject) &/ sKey
    SaveWindow(hObject, sKey)
  ELSE 'IF Object.Is(hObject, "SidePanel") THEN
    IF NOT sKey THEN TRY sKey = hObject.Name
    sKey = GetTopLevel(hObject) &/ sKey
    'DEBUG sKey
    TRY ME[sKey] = hObject.Settings
  ENDIF
  '
END
'
STATIC PRIVATE FUNCTION Path_Read() AS String
  '
  DIM sPath AS String = Application.Env["XDG_CONFIG_HOME"]
  IF NOT sPath THEN sPath = System.User.Home &/ ".config"
  RETURN sPath &/ "gambas"
  '
END
'
STATIC PUBLIC FUNCTION Array(...) AS String[]
  '  
  DIM aVal AS NEW String[]
  DIM iInd AS Integer
  DIM sVal AS String
  DIM vVal AS Variant
  '
  FOR iInd = 0 TO Param.Max
    vVal = Param[iInd]
    IF IsBoolean(vVal) THEN 
      sVal = IIf(vVal, "1", "0")
    ELSE
      sVal = CStr(vVal)
    ENDIF
    aVal.Add(sVal)
  NEXT
  '
  RETURN aVal
  '
END
' 
PUBLIC SUB Reload()
  '
  Load
  '
END

Conclusies:

Classe begint met:
EXPORT
CREATE STATIC

De bruikbare, dwz van buitenaf zichtbare elementen zijn vet weergegeven in de broncode hierboven.

Het path is een eigenschap die van buitenaf (enkel) leesbaar moet zijn.

Dat wordt gerealiseerd met een interne variabele die in de (automatisch bestaande) functie _Read() wordt gebruikt om de externe alleen-lezen variabele af te schermen. Als gevolg komt die eigenlijk twee keer voor, waarbij je onderscheid moet kunnen maken tussen de namen, wat hier gedaan wordt door de private variabele als $sPath te definieren, en de externe gewoon als Path:

 
STATIC PROPERTY READ Path AS String

PRIVATE $sPath AS String
'
STATIC PRIVATE FUNCTION Path_Read() AS String
  '
  DIM sPath AS String = Application.Env["XDG_CONFIG_HOME"]
  IF NOT sPath THEN sPath = System.User.Home &/ ".config"
  RETURN sPath &/ "gambas"
  '
END

Allerlei procedures (groene bol) zonder of met (één of meer optionele) parameters:

PUBLIC SUB Save()
PUBLIC SUB Reload()
PUBLIC SUB Clear(ParentKey AS String)
PUBLIC SUB Write(hObject AS Object, OPTIONAL sKey AS String)
PUBLIC SUB Read(hObject AS Object, OPTIONAL sKey AS String, OPTIONAL vDefault AS Variant)

De array ziet er zo uit (groene kubus):

STATIC PUBLIC FUNCTION Array(...) AS String[]

Zelf Component maken

Zelf maak je in de IDE een nieuw project, of wijzigt* een bestaand via menu:

Project, Properties, Options

kruis aan:

Options, Component: Yes. (Advancement: Beta)

Dat voegt onmiddellijk de tabbladen “Provides” en “Requieres” toe:

Schermafbeelding project venster gambas

Component in Gambas2

* Wijzigen van een bestaand, niet als component gestart project naar “component” leverde me een crash op bij een klik in het tabblad “Provides” als daar nog niets aanwezig is.

Bij een nieuw project krijg je dan
Classes:

  • CContainer
  • CControl

En onder Data de Controls:

  • ccontainer.png
  • ccontrol.png

Class CContainer bevat:

' Gambas class file

EXPORT

INHERITS UserContainer

PUBLIC SUB _new()

END

En Class CControl bevat:

' Gambas class file

EXPORT

INHERITS UserControl

PUBLIC SUB _new()

  DIM hLabel AS Label
  
  hLabel = NEW Label(ME) AS "MyLabel"
  hLabel.Text = "Gambas!"
  hLabel.Font = Font["+4,Bold,Italic"]
  hLabel.Border = Border.Plain
  
END

PUBLIC SUB MyLabel_Enter()

  LAST.Text = "Gambas Almost Means BASIC!"

END

PUBLIC SUB MyLabel_Leave()

  LAST.Text = "Gambas!"

END

De IDE maakte deze bestanden aan, samen met 2 grafische bestanden, en ik veronderstel dat de code een soort voorbeeldcode is die je zelf kan aanpassen of weggooien als je ze niet nodig hebt.

Bij een bestaand project met classen die je algemeen wil hergebruiken: Begin van je project en pas aan zoals hierboven uitgelegd. Ter vergelijking kan je de broncode van Gambas2 gebruiken als voorbeeld.

In de broncode van je class zelf moet je volgens de documentatie met sleutelwoord “EXPORT” aangeven dat ze geëxporteerd moet worden.

Je kan er een gewoon source archive van maken (tar.gz) om te verspreiden naar de gebruikers.

Je kan als gebruiker het project “compileren”; met “make executable”. Daar krijg je een extra optie:

“Install in the user component directory”

Daardoor wordt de component bruikbaar vanuit je Gambas2 IDE, menu Project, Properties, Components.
Hij komt onderaan in de lijst van de componenten, onder de extra titel “User Components”. Geniaal eenvoudig!

De bestanden .gambas en .component worden geïnstalleerd(*) in
~/.local/lib/gambas2
waardoor ze bruikbaar worden in al de gebruiker’s gambas2 projecten.

* Opgelet!
Ze worden daar niet naartoe gekopieerd, maar er wordt slechts een link, een verwijzing gemaakt naar de gecompileerde versie (i.e. de locatie waar je ze gecompileerd hebt). Gooi het originele project daar weg, en je hebt een probleem!

Nota: virtuele class
In geval van een hierarchie van klassen, waarbij de hoogste een virtuele klasse is, die nooit rechtstreeks gebruikt wordt, moet je ze benoemen met een begin-underscore “_”, zodat ze onzichtbaar wordt. De verwijzing INHERITS hoofdklasse in de subklassen ook aanpassen naar INHERITS _hoofdklasse natuurlijk.

Toetsencombinaties met control: Ctrl-s

Om te bewaren wordt in programma’s standaard toetsencombinatie Ctrl-s gebruikt, dat kan je ook in je Gambas programma’s.

Voorbeeldsituatie:

  • een scherm FMain met een paar tekstvelden “TextLabel1”, “TextLabel2″…
  • de toetsen worden opgevangen in het aktieve scherm “FMain”.

Dat kan in Gambas2 zo:

PUBLIC SUB _new()

END

PUBLIC SUB Form_Open()
  
END

PUBLIC SUB Form_KeyPress()

  IF Key.Control AND (Key.Code = Key["A"] OR Key.Code = Key["a"])
    TextLabel1.Text = "CTRL-"
    TextLabel2.Text = "Aa"
  ENDIF 

  IF Key.Control AND Key.Code = Key["z"]
    TextLabel1.Text = "CTRL-"
    TextLabel2.Text = "z"
  ENDIF 

END

Group van een control definiëren vanuit code

In de IDE kan je de group invullen bij de eigenschappen van een control, rechts in de lijst van eigenschappen.
Bovenaan heb je telkens

(Class)
(Name)
(Group)

Die group kan je gebruiken om een aktie op te vangen, bv een klik of een drop event.

Als je een object of control vanuit code gemaakt hebt, kan je niet eevoudigweg die eigenschap invullen zoals de andere eigenschappen.

FOR i = iEerste TO iLaatste
  arrayControls[i] = NEW ToggleButton(frameKnoppen)
  WITH arrayControls[i]
    .Text = Str$(i)
'    .Group="groupKnoppen"
    .Drop = TRUE
  END WITH
NEXT

Geen enkel van die “tussen haakjes” eigenschappen kan je vanuit code wijzigen; ze worden bepaald bij declaratie/initiatie.

De manier om die group toe te kennen is de declaratie/initiatie uit te breiden met de groupnaam als string in AS “groupname”

FOR i = iEerste TO iLaatste
  arrayControls[i] = NEW ToggleButton(frameKnoppen) AS "groupKnoppen"
  WITH arrayControls[i]
    .Text = Str$(i)
'    .Group="groupKnoppen"
    .Drop = TRUE
  END WITH
NEXT

Dan kan de group verder gebruikt worden om events op te vangen:

PUBLIC SUB grpKnoppen_Drop()
  LAST.Text = Drag.Data
  LAST.Value = TRUE
END

Snel data ingeven met een tekstgebied (TextArea)

Gambas2 TextArea Input, leeg (screenshot)

Tekstgebied voor invoer

Als je op een scherm (Form) data laat ingeven moet je altijd een compromis zoeken tussen

  1. efficiëntie van de input
  2. controle van de input

Door punt “controle” zou je geneigd kunnen zijn meer aparte tekstvelden te gaan gebruiken, waarvan je telkens de invoer controleert. Waarbij de gebruiker, om zijn hele invoer te kunnen doen, dan wel telkens van veld moet veranderen (indien: implementeer TAB mogelijkheid!).

Een tekstgebied (TextArea), dat je eventueel “in de hoogte” vormgeeft, laat toe snel opeenvolgende woorden (zinnen) in te geven, hier vooral een reeks onder elkaar dus.

Ik laat de gebruiker achtereenvolgens de invoer doen, en op het moment dat hij het tekstgebied verlaat, doe ik de controle en geef feedback. Daarvoor worden de regels van het tekstgebied gesplitst in “zinnen”, die elk als één invoer beschouwd worden.

Gambas2 TextArea Input End (screenshot)

Na drie lijnen invoer, een enter, en nog een…

PUBLIC SUB doImportClassValues()

  DIM sLine AS String
  DIM hArrStr AS NEW String[]
  hArrStr = Split(txaeClassNames.Text, gb.NewLine) 
  
  setState(cAdd)
  
  FOR EACH sLine IN hArrStr
    doCheckSave(sLine)
  NEXT 
  

Om het toetsenbord niet te moeten verlaten bij het einde van de invoer, tel ik twee achtereenvolgende “volgende regel” (enter/return) als teken om te stoppen: gebruiker heeft een lege regel ingevoerd, en daarna nog één. Dat is het teken voor “klaar”, de verwerking van de invoer wordt gestart.

Om gemakkelijk toegang te geven tot de invoer in het tekstgebied gebruik ik bv een dubbelklik op het tekstgebied.

De teller voor het aantal enters is vooraf hoger gedefinieerd als
PRIVATE $iLastEnter AS integer

De toets voor enter/return wordt zo getest en geteld:

PUBLIC SUB txaeClassNames_KeyPress()
'
  IF Key.Code = Key.Enter OR Key.Code = Key.Return
    INC $iLastEnter 
    IF $iLastEnter = 2
      doCheckSaveValues(txaeClassNames.Text)
      $iLastEnter = 0
    ENDIF 
  ELSE 
    $iLastEnter = 0
  ENDIF 
'
END

Inputbox

Gambas InputBox

Snel data laten ingeven vanuit code

De inputbox komt niet voor in het menu rechtsonder, bij de tabbladen Form of Container, en daardoor zou je deze functie over het hoofd kunnen zien.

Ze is handig om vanuit code snel invoer toe te laten, omdat je het antwoord onmiddellijk als waarde terugkrijgt.

De tekst die weergegeven moet worden als vraag om invoer of als verklaring, wordt als parameter meegegeven.

Op dezelfde manier kan (optioneel) een titel voor het venster gegeven worden.

Ook optioneel is een “standaardwaarde”, wat wil zeggen dat ze vooraf ingevuld wordt;

teruggeefwaarde = InputBox("Geef een getal (in cm) van 1-999 ", "Lengte-invoer", "***")

Er kunnen zowel cijfers als letters ingegeven worden, dus invoer controleren!

De tekst met de vraag binnen het venster, kan opmaak kenmerken meekrijgen:

InputBox("Geef een getal <em>(in cm)</em> <br> <font color='darkgreen'>van 1-999</font>", "Lengte-invoer", "***")

Opgelet; de sterretjes betekenen hier niet ‘onzichtbare ingave’ zoals voor “wachtwoord”.

Het PaxHeaders spook / PaxHeaders Ghosts

PaxHeaders Ghosts (NL: Het PaxHeaders spook …)

Suddenly, the packages that I make with Gambas2 seem to be much bigger than before. If I examine (look into the tar.gz files with Konqueror), they seem to contain the compiled .gambas file, which has landed in the source directory some moment; so I remove that. But also I found some mysterious “PaxHeader” directories. These always end with a 4 digit number, that becomes bigger at every creation. This can be reproduced by making an new project, and create a package from within the Gambas2 IDE. One example of a directory that appears is:

PaxHeaders.5028

This occurs for me on OpenSuse 12.2 Mantis, with Gambas2 (2.24), on openSUSE Linux kernel 3.4.47-2.38-desktop.

On this moment I don’t see anything mentioned on the gambas-user list, I suppose it has nothing to do with gambas itself. One mention I found is on a KDE list.

You can “see” this gosts with Konqueror, but not with Ark of with Dolphin. Maybe Konqueror sees something that is not there? (or the other way around in Ubuntu?)

Might be corrected with an openSUSE update soon…


Het PaxHeaders spook

Op een bepaald moment ontdek ik dat de tar.gz bestanden die gemaakt worden vanuit de Gambas2 IDE veel groter geworden zijn. Met KDE’s bestandsbeheerder zie ik dat er een .gambas inzit, wat staat voor het gecompileerde programma. Dat is in de source directory terechtgekomen, en wordt zo als bestand mee in het pakket opgenomen; ik verwijder het uit de broncodemap.
Ik merkte echter ook dat er in de .tar.gz een aantal eigenaardige directories zitten.
Ze hebben een naam die begint met PaxHeader en eindigen met een 4-cijferig nummer, zoals bv

PaxHeaders.5028

Het komt voor op de huidige OpenSuse 12.2 Mantis, with Gambas2 (2.24), on openSUSE Linux kernel 3.4.47-2.38-desktop.

Je “ziet” het ook alleen met Konqueror, niet met Ark of met Dolphin, wat er misschien op wijst dat Konqueror iets weergeeft dat er helemaal niet is?

Vermoedelijk ligt het anders aan KDE of de onderliggende bibliotheken die gebruikt worden om de bestanden in te pakken.

Ik hou in de gaten of er updates zijn, en wanneer het verholpen is…


update 5/9; dit zou een verklaring kunnen zijn (hoewel omgekeerd tussen konqueror en dolphin): een bug in de bestandsbeheerder die enkel een foute weergave doet; hier vermelding bij Ubuntu, een andere distributie, die ook met KDE werkt:


…show misleading PaxHeader..

Version: (using KDE 4.3.0)
Installed from: Ubuntu Packages

Some tar files created in KDE 4.3 from within Dolphin’s context menu do not
show their contents properly. When clicking on them to show them as a folder,
they have some PaxHeader folders inside and these have the wrong directory
structure. However, when deflating the tar.gz file the resulting directory is
in fact as it should be. Therefore, it is only the Dolhin view mode that is
bugged, not the creation or deflation of the tar.gz files.

Parameters doorgeven

Parameters tussen haakjes

Parameter passing of parameters doorgeven naar een procedure, functie (of een klasse) gaat door ze tussen gewone ronde haakjes te zetten:

procedure1(string1, string2)

resultaat = functie1(parameter1, parameter2)

De parameters kunnen getallen, tekst enz. zijn, afhankelijk hoe ze gedeclareerd zijn in de procedure.

Bv in de FMain form toon je het resultaat in een TextLabel1:

TextLabel1.Text = produkt(15, 3)

De procedure kan er zo uitzien:

PUBLIC SUB produkt(i AS INTEGER, j AS INTEGER)
   RETURN i * j
END

Een array als parameter

Het wordt een beetje ingewikkelder als je geen gewone parameters (integer, float, string..) wil geven, maar een “hoger” type, als een array.

Stel dat de klasse er zo uitziet:

PUBLIC SUB _new(ArrayOfParameters AS VARIANT)
   iNumberOfParameters = ArrayOfParameters.Count
   myParameters = ArrayOfParameters
END

En volgende methodes bevat:

PUBLIC SUB getParameters() AS Integer
   RETURN myParameters.Count
END

PUBLIC SUB getParameter(i AS Integer) AS Float
   RETURN myParameters[i]
END

De aanroep kan dan zo gebeuren (code van FMain):

PUBLIC arrFloats AS NEW FLOAT[]
PUBLIC hClass AS CReceiver


PUBLIC SUB _new()
   arrFloats.Add(1.1)
   arrFloats.Add(1.3)
   arrFloats.Add(2.4)
'
   hClass = NEW CReceiver(arrFloats)
END

PUBLIC SUB Form_Open()
   SpinBox1.MaxValue = arrFloats.Count - 1
   SpinBox1.Value = SpinBox1.MaxValue
END

PUBLIC SUB Button1_Click()
   TextLabel1.Text = hClass.getParameters()
END

PUBLIC SUB Button2_Click()
   TextLabel2.Text = hClass.getParameter(SpinBox1.Value)
END