Een array arrFileNames moet gevuld worden met de namen van de bestanden uit een directory sDirectory.

En hoewel je de directory kan gaan doorlopen en één voor één de namen uitlezen en in een array toevoegen met “insert’, bestaat er een snelle en handige manier in gambas met “Dir“, dat een array teruggeeft op een selectie van bestanden:

aFiles = Dir(sDirectory, "*.txt")


Voorbeeld van uitlezen van beelden en opeenvolgend tonen in bestaande Picturebox1 :

 DIM s AS String
...
 TRY aFiles = Dir(sDirectory, "*.png")
 IF ERROR 
    DEBUG Error.Text
  ELSE 
    FOR EACH s IN aFiles
      Picturebox1.Picture = Picture.Load(sDirectory &/ s)
      Message.Info(s) ' toon bestandsnaam en wacht
    NEXT 
  ENDIF 

Een van die nuttige, toevallige ontdekkingen: wat de Action betekent in menu: mailinglist

items .. which can throw “actions”

De Action helpt in het beheer van complexe toepassingen met veel menu’s en knoppen, die overlappen in functie, en waarvan de toestand (beschikbaarheid) moet aangepast worden naargelang omstandigheden (itt een altijd bereikbaar menu als Help, About,..).

Met dat Action veld kan je een “actie” definiëren waarop die verschillende “controls” van toepassing zijn, zoals de actie “bewaar huidig document”, actie bv genaamd “ActSaveFile” (zou bv voor menu “File, Save” en shortcut ctrl-s en een toolbutton “tlbtSave” kunnen zijn).

Je kan volgens de beschrijving die met één procedure na het bewaren inactief maken bv.

action["ActSaveFile"].Enabled = FALSE

PUBLIC SUB inactivateSave(bNewState AS Boolean)
  Action["ActSaveFile"].Enabled = bNewState
  mniOther.Enabled = NOT bNewState  ' some other alternating function
END

Bovendien kan je op basis daarvan ook code laten uitvoeren; acties worden gecheckt, je moet alleen de procedure schrijven om er iets mee te doen; de parameter is de naam van de actie en return waarde is een boolean:

PUBLIC SUB Action_Activate(sAction AS String) AS Boolean
  DEBUG sAction
  SELECT sAction
    CASE "ActSaveFile"
      saveCurrentFile()
    CASE
      ' ...
  END SELECT
  RETURN TRUE ' might be located in CASEs as result there
END

Meer uitleg over Actions op de (niet-vertaalde) documentatiepagina: http://www.gambasdoc.org/help/comp/gb.qt/action?nl

Bij weergave van gegevens van een week geleden tot nu moet je de begindatum van die periode bepalen.
Hoe kan ik de datum van een week terug vinden?

De huidige datum in Gambas krijg je met:

date()
of
date(now())

(Deze commando’s kan je uitproberen in het Console venster onderaan in Gambas IDE, met vraagteken plus commando, zoals “ ? date()“.)

De gewone now() geeft ook de tijd erbij. Maar het interessante aan now() is dat je van daaruit kan teruggaan naar de dag van nu min een week:

date(now()-7)

In de Console moet het zo:

? Date(Now()-"7")

Als je dus from.. until datums nodig hebt, kan je hiermee je “from” datum berekenen.

De aparte waarden voor jaar, maand en dag indien je die nodig hebt, bv voor het opstellen van een SQL vraag:

year(date(now()-7) & "-" & month(date(now())-7) & "-" & day(date(now())

Of als je de hele voorbije week nodig hebt, kan je een array vullen met die dagen:

 PUBLIC SUB fillLastWeek(arrLastWeek AS Date[], iBack AS Integer, OPTIONAL bTodayIncl AS Boolean)
  
  DIM dStart AS Date
  DIM dRun AS Date
  DIM dEnd AS Date
  DIM i AS Integer
  DIM iShiftToday AS Integer = 0
  
  DEBUG arrLastWeek.Type
  
  IF bTodayIncl
    iShiftToday = 1
  ENDIF 

  IF iBack = 0
    iBack = 7 
  ENDIF 
  
  dStart = Date(Now() - (iBack - iShiftToday))
  
  dRun = dStart
  
  FOR i = (1) TO (iBack)
    arrLastWeek.Add(dRun)
    dRun = Date(dStart + i)
    'DEBUG "i=" & i & " iBack=" & iBack & " iShiftToday=" & iShiftToday & " dRun = " & dRun
  NEXT 
  
END

  

Wordt aangeroepen:

fillLastWeek(arrLastWeek, 7)

of

fillLastWeek(arrLastWeek, 7, TRUE)

Nog een vraag: wat was de eerste dag van deze week?

? date(now()-weekday(Now())+"1")

Zonder de +1 kom je op zondag uit; je kan die 1 ook aftrekken van je dagnummer natuurlijk:

? date(now()-(weekday(Now()-"1")))

Zeker nuttig is ook DateAdd, waar je bij een datum aangeeft welke eenheid er hoeveel bij moet geteld worden:

DateAdd(date1, gb.Day, 7)

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

Tekstgebied voor invoer

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.

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

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

Controls op het scherm (en sommige andere objecten) hebben een “tag” eigenschap, die je zelf kan gebruiken naar eigen goeddunken. Een aantal controls in een container of group kunnen herkend worden aan de waarde van de tag property. Zo kan je alle “child” objecten van een container doorlopen tot je de gewenset “tag” inhoud vindt. Dat kan zowel een string als een getal of eender welke ” variant” zijn. Ps: Een timer heeft geen “tag”, een Form wel.

Bij een Form kan je de tag gebruiken om een toestand bij te houden, bv add/edit/saved mode.

Wil je dezelfde “event handlers” gebruiken voor een aantal controls, dan kan je ze in een group opnemen. In de eigenschappen staat de group bovenaan, onder de control (Class) en (Name): (Group).

Stel dat je 12 knoppen op je scherm hebt, die je allemaal als Group “grpKnoppen” hebt gegeven. Dan kan je:

PUBLIC SUB grpKnoppen_Click()
  
  Message.Info("Knop geklikt: " & LAST.Name)
  
END

Je kan verschillende objecten in dezelfde groep steken, en dan kan je voor alle de Tag eigenschap (of Name, Text, …) gebruiken.
Maar je moet er wel op letten dat de eigenschap die je aanspreekt bestaat (desnoods op object type controleren in je code).
bv grpObjecten:

PUBLIC SUB grpObjecten_Click()
  
  Message.Info(LAST.Name & "; " & LAST.Text & "; Tag:" & LAST.Tag)
  
END

In de Tag kan je een verwijzing bewaren, bv

• index van een Array met andere waarden
• record id van een record uit een database (via result set bv)

Je kan ook gebruik maken van een container waarin de objecten zitten (bv Frame1 dat Buttons bevat), en die je kan aflopen als “enumerated type”:
Als je een ListBox1 op je Form hebt kan je zo de objecten oplijsten:

PUBLIC SUB showAllChildren()
  
  DIM hObject AS Object
  
  FOR EACH hObject IN Frame1.Children
    ListBox1.Add(hObject.Name & ": " & hObject.Tag, 0)
  NEXT 
  
END

Dit is het meest minimale voorbeeld van klik en sleep of drag’n drop: je sleept een tekst van de linkse tekstbox naar het rechtse tekstlabel

Schermafbeelding Kleinste klik en sleep voorbeeld

Je hebt twee objecten nodig (zie schermafbeelding), en de volgende code in FMain.Form :

Van tekstbox …

PUBLIC SUB TextBox1_MouseDrag()
  IF Mouse.Left
    TextBox1.Drag(TextBox1.Text)
  ENDIF 
END

naar tekstlabel:

PUBLIC SUB TextLabel1_Drop()
  TextLabel1.Text = Drag.Data
END

Het voorwerp dat ontvangt moet de eigenschap voor ontvangen van “drop” ingesteld hebben.
Dat kan zowel in de schermontwerper bij eigenschappen, als in code (bv bij openen venster):

PUBLIC SUB Form_Open()
  TextLabel1.Drop = TRUE
END

Wat je nog extra kan doen:

• Oorspronkelijke tekst laten verdwijnen bij slepen van ..
• Icoon van het gesleepte tonen terwijl het slepen doorgaat (meestal als je een beeldje sleept).
• Andere dingen (als waarde opslaan in buffer, teller verhogen enz)
• Na “drop” het object afsluiten*: in PUBLIC SUB TextLabel1_Drop() regel toevoegen met TextLabel1.Drop = FALSE

* (26/6/2014 correctie: afsluiten voor nieuwe drop natuurlijk door de waarde FALSE, niet TRUE zoals er eerst stond).