Een voorbeeldje van wat in mijn MMain zit bij een programma met meer vensters
(in de Gambas IDE zijn dat de Forms):
Public Sub doQuit()
'
Dim hWindow As Window
'
Settings.Save ' other code
hRunCounter.appClose() ' other code
For Each hWindow In Windows
hWindow.Close
Next
'
EndOther code:
Settings.Save: omdat ik de component Settings gebruikt.
hRunCounter: ik hou een teller bij van het starten en sluiten van het programma
Voor een eigen programma waar de inhoud wordt bijgehouden in een git repository, zou ik die willen kunnen updaten vanuit mijn Gambas app. Sinds een tijdje is in de IDE een voorziening ingebouwd om de git branch om te schakelen enz vanuit de IDE, dus daar zit mogelijk een aanknooppunt.
Algemeen: een commando kan je vanuit Gambas lanceren met shell of exec.
In de broncode van gambas 3.18.0 vind je een map VersionControl met een Class CVersionControl, met een subclass CVersionControlGit.
Daarin:
Private Sub RunShell(sCmd As String, Optional bSilent As Boolean) As String
'
Return VersionControl.Shell("cd " & Shell(Project.Dir) & " && " & sCmd, bSilent)
'
End
In de Module (naam zonder M) “VersionControl” vind je:
Public Sub Shell(sCmd As String, Optional bSilent As Boolean, Optional aEnv As String[]) As String
'
Dim sResult As String
'
If Not bSilent Then Insert(sCmd & "\n")
Shell sCmd With aEnv To sResult
If Process.LastValue Then
$sLastResult = sResult
Insert(sResult)
Endif
Return sResult
'
End
Foutmelding als “System error 110” vanuit sql zijn soms veroorzaakt door een slechte/trage verbinding.
Best maak je een standaard db-test project dat niets doet behalve de verbinding testen, en dan kan je dat steeds weer gebruiken.
Is de database verbinding nog ok?
Het probleem dat hier kan optreden is de duur dat de databaseverbinding open blijft. Hoe langer het programma draait, hoe meer kans dat de database op een bepaald moment niet bereikbaar is. Typisch is na het blijven openstaan gedurende de nacht; eerste handeling de volgende dag doet het programma crashen als de databasefouten niet juist worden opgevangen.
Het alternatief kan zijn bij elke aktie op de database de verbinding te openen en te sluiten.
Of de verbinding te testen en indien niet meer goed, te heropenen.
Hoe best de procedures maken in de Data module?
Je kan een “result” teruggeven, die kan verder verwerkt worden in de aanroepende code:
PUBLIC SUB getWorkedOn(sWork AS String) AS Result
'
DIM myResult AS Result
DIM sSql AS String
'
sSql = "SELECT * FROM reg "
sSql &= "WHERE reg_type='U' AND ord_code = &1 "
'
TRY myResult = $hConNoxqs.Exec(sSql, sWork)
'
IF ERROR
sLastError = Error.Text
RETURN NULL
ELSE
RETURN myResult
ENDIF
'
END
Of je kan een waarde teruggeven:
PUBLIC SUB getEmployeeCount() AS Integer
'
DIM iMonthNames AS Integer
'
$hResEmployees = MData.getEmployees(MCommon.bActiveOnly)
'
iMonthNames = $hResEmployees.Count
SetLog("Employees used: " & iMonthNames & ", active employees: " & Str$(MData.activeEmployees("A")))
'
RETURN iMonthNames
'
END
update van gambas.copyleft.be/blog/checklist-project van 2014/2017
Start een nieuw project: commandolijn, lib, grafisch, databank, …
Algemeen: gebruik settings, foutbeheer, log, versienummer, ..
commandolijn, lib, grafisch, databank
commandolijn, lib, grafisch, databank
commandolijn, lib, grafisch, databank
Desktop (grafische gebruikers-bediening):
Me.Icon of neem dat eventueel mee op in de procedure van de venstertitel. Je kan het icoon laten evolueren (kleur, scherpte, vorm) om de graad van de hiërarchie van het venster te tonen; bv hoofdvenster, 1e sub, sub-van-1e-sub… Iconen in mapje met namen voor level; iconL0.png ,iconL1.png, iconL2.png, …Databank toegang
Ik gebruik van in mijn Gambas programma een databank (type mysql/mariadb), waarvoor ik over het netwerk inlog naar de databank.
Ik moet de instellingen ergens bewaren; Gambas heeft daarvoor zijn “Settings” in een configuratie-bestand. Daarin bewaar ik server-adres, login, wachtwoord en databanknaam. Mijn toepassing kan verschillende databanken aanspreken, ik noem die “datasets”
Dataset
De dataset situeert zich op een server en heeft zelf als eigenschappen dat ze een naam en een omschrijving heeft.
Voorbeeld van enkele datasets die ik gebruik:
De korte naam wordt intern gebruikt, bv in programma’s en documentatie.
Andere server?
Terwijl ik de applicatie ontwikkel, wil ik niet op de “goede” databank werken, om die data niet te beschadigen, eventueel is dat ook een andere server.
Ik kan andere instellingen gebruiken (bewaard in het configuratie bestand).
Ontwikkel-test-gebruik
Op het moment dat ik wil testen op de goede data, moet ik ofwel het configuratie bestand verwisselen voor een andere versie, of – en dat zou nog handiger zijn – omschakelen in mijn toepassing zelf. In mijn programma zou ik moeten kunnen kiezen voor de databanken van de ontwikkeling, die om te testen, of de echt gebruikte databank “in productie”.
Onderweg – ter plaatse
Die drie verschillende “omgevingen” noem ik de DataContext. Die DataContext kan ook nog verschillen op een andere manier: als ik op mijn laptop werk, offline van mijn productieomgeving, wil ik een lokale kopie op de “localhost” gebruiken (en moet ik daar gemakkelijk naar kunnen overschakelen). Als ik dan op het werk kom, schakel ik over naar de productie-databank, dus hier zijn het eerder verschillende “situaties”.
DataContext
Ik wil dus omschakelen tussen
* Voorbeeld 1:
* Voorbeeld 2:
Instellingen
In mijn instellingen wil ik dus voor een verbinding de combinaties kunnen maken van de datacontext en de dataset (“DataContextX-Dataset”, ofwel de “Connection” gegevens).
Datacontext-Dataset
In het config bestand ziet dat er zo uit:
[DataContext0-Crm]
host="server.domain.tld"
login="myname"
password="qsdljfsdfjqsdljjdsqf"
database="crm"
Ik kan heel flexibel een andere verbindings-combinatie maken voor mijn laptopwerk:
[DataContext1-Crm]
host="localhost"
login="myname"
password="oupotykhlvkhsjhf"
database="crm"
Om aan te geven waarvoor de DataContext0 of DataContext1 staat, definieer ik dat ook in de instellingen:
[DataContext0]
Name="production"
Description="Ter plaats op het werk"
[DataContext1]
Name="mobile"
Description="laptop localhost kopie databank"
En ook over de datasets kan ik die informatie bijhouden:
[DataSet]
Pers="personeelsgegevens"
Reg="tijdsregistratie"
Crm="klanten bestanden"
De dataset kan in een module of library gedefinieerd zijn als constante string:
ModCrm
Public csDATASET as String = "Crm"
Public hConData as Connection
...
Het bewaren in de instellingen en het terug ophalen kan je systematisch doen door daar een “libary” DataContext voor te maken, waardoor dat ook altijd op dezelfde manier gebeurt, en met dezelfde syntax. De library maak je in Gambas als library project, en als uitvoerbaar programma kan die als libarary gebruikt worden in een ander project.
CDataContext
De klasse CDataContext moet aanbieden:
– nieuwe datacontext maken (met naam en beschrijving gegeven)
– nieuwe dataset maken (met naam en beschrijving)
– opvragen van de beschrijving van een gegegven dataset of datacontext
– context kiezen/instellen (vanaf dan wordt gekozen context gebruikt als “huidige”)
– bewaren van nieuwe instellingen voor een datacontext, dataset en connection
– verbinding maken met de databank van een gegeven dataset voor een gegeven connection (met “huidige” context)
– opvragen van allerlei informatie over de bewaarde verbindingen, bv of een bepaalde bestaat, hoeveel er zijn, of de lijst van …
Ik heb een grappige manier gevonden om iets te demonstreren in je Gambas3 programma.
Ik heb in het “Help” menu (of ? menu) naast About, What’s new, Licentie, Help, enz een item bijgemaakt: Demo.
Ik laat daarbij op het scherm, in volgorde, oplichten wat een gebruiker achtereenvolgens moet doen.
Oplichten doe ik door tijdelijk een (achtergrond-)kleurtje te geven, bv geel. Na een kleine wachttijd van 2 seconden (die gemakkelijk kan aangepast worden in de code – misschien moet ik het instelbaar maken voor de gebruiker), krijgt het voorwerp terug de normale kleur.
mniHelpDemo_Click()
'
Dim iWaitABit as integer = 2
'
'...
'
Button1.Background = Color.Yellow
'
Wait iWaitABit
'
Button1.Background = Color.Background
'
Tabstrip1.index=4
'
Tabstrip1.Background = Color.Yellow
'
Wait iWaitABit
'
Tabstrip1.Background = Color.Background
'
Textbox1.Background = Color.Yellow
'
Wait iWaitABit
'
Textbox1.Background = Color.Background
'
'
combobox1.Background = Color.Yellow
'
combobox1.Popup
'
Wait iWaitABit
'
' combobox1.Popdown - doesn't exist? *
'
combobox1.Background = Color.Background
'
' etc...
* Combobox sluiten
Het enige wat niet goed werkt is dat ik een combobox (rolluikje met keuzes) wel kan openen om te tonen wat er allemaal in staat, maar ik kan het niet sluiten zonder een keuze te maken. Dit was niet voorzien in Gambas3, maar zal er aan toegevoegd worden vanaf de volgende versie.
Het is al opgenomen in de broncode, in commit:
https://gitlab.com/gambas/gambas/-/commit/9d08d1371982221fe876fb29ea12d020d2dd264b
Commit 9d08d137
authored 4 days ago by Benoît Minisini’s avatar Benoît Minisini
ComboBox: Close() is a new method that closes the ComboBox popup.
‘
[GB.QT4]
* NEW: ComboBox: Close() is a new method that closes the ComboBox popup.
‘
[GB.QT5]
* NEW: ComboBox: Close() is a new method that closes the ComboBox popup.
Situatie: je hebt een form FMain, en je wil een vraag stellen waarbij je een antwoord verwacht van de gebruiker, dat je nodig hebt voor het verdere verloop van het programma.
Als dat een eenvoudig Ja/Neen of iets dergelijks is, kan je gewoon Message.Question(...) gebruiken; daarbij kan je detecteren welke knop gedrukt is (de waarde komt uit de Message return waarde);
If Message.Question("Really delete from database?", "Yes", "No-Cancel") = 1
– er wordt geteld vanaf 1 (bv 1=”ok” 2=”ok+save”, 3=”cancel”)
– laatste keuze is altijd de “cancel” keuze, is ook default
Antwoord dus bv 1, en daarop reageren via bv SELECT.
Maar als je echt invoer van een woord of tekst hebt, hoe dan?
Ik weet niet of het “de” juiste manier is in Gambas, maar ik loste het zo op:
Ik maak een Form FGetText met enkel
– een tekst voor de vraag (TextLabel)
– een tekstveld voor de invoer (TextBox)
– een sluiten-knop (Button)
En een procedure die public is om de vraag op te geven: setQuestion(s as string) en die in de form die vraag in een TextLabel steekt.
Deze form wordt aangeroepen
Dim sNewFile As String
'
MMain.sGetText = ""
FGetText.setQuestion("New text title or enter for default.txt ")
FGetText.Show
Wait 0.1
While Not FGetText.Closed
' this is where the form works...
Wait 0.1 ' until it is closed
Wend
If (MMain.sGetText) ' this is where the answer is found
' etc.
Als de Form gesloten wordt, geeft die eerst de waarde die ingevuld is door aan een public variabele in MMain. Deze procedure wordt aangeroepen na een “enter of return”, of de textbox nu leeg of gevuld is.
Het programmaverloop kan daar dan de waarde ophalen nadat het venster gesloten is; indien leeg kan een voorgedefinieerde standaardwaarde gebruikt worden.
Ik heb lang gewacht om dit uit te zoeken omdat ik dacht dat er toch een Gambas manier moest zijn om dat anders te doen, en misschien vind ik die ooit nog… maar toch..
Veel plezier..
Gambas maakt in de laatste versies gebruik van git, en toont dat ook in zijn IDE.
Ook bij de ontwikkeling van Gambas3 wordt git gebruikt. Een overzicht op:
https://gambaswiki.org/wiki/howto/git
Maar Gambas bestaat van voor git, en als je git gebruikt met een Gambas project rijst de vraag:
Welke bestanden moet je opnemen in git?
Bij het werken met git kies je welke bestande je onder git toezicht zet, en lokale bestanden die niet nodig zijn voor de ontwikkeling bij een andere programmeur, hoeven niet/mogen niet mee opgenomen worden in git. Sommige daarvan zijn ook onzichtbare bestanden/directories.
Gambas zelf (sinds 3.6) maakt een .gitignore bestand aan, dat git vertelt wat moet genegeerd worden. Daarin bv .gambas, wat de gecompileerde versie is van je project (die zet je altijd beter buiten je projectdirectory want anders wordt die ook mee ingepakt als je een export .tar.gz maakt vanuit de IDE.
Ook andere dingen moeten niet meegaan: de .directory bv, die KDE gegevens bevat.
Voorbeeld van een .gitignore: versie5 , oudere versie1 en .gitignore van Gambas3 zelf …
Huidige (upd 09/2021):
#---- Gambas files to ignore (v5)
*.gambas
.lock
*~
core
core.*
vgcore
vgcore.*
.kdbg*
.*.prof
.lang/*.pot
.gambas/*
.settings
.startup
.list
.info
#----
.directory
.icon.png
Waarbij
De .gitignore van het Gambas project zelf:
Makefile
Makefile.in
libtool
ltmain.sh
stamp-h1
warnings.log
.deps/
aclocal.m4
config.guess
config.log
config.sub
configure
install-sh
autom4te.cache
config.h
config.h.in
config.status
config.cache
compile
depcomp
missing
/m4/libtool.m4
/m4/ltoptions.m4
/m4/ltsugar.m4
/m4/ltversion.m4
/m4/lt~obsolete.m4
.libs/
*.la
*.lo
*.o
*.a
.dirstamp
*_moc.cpp
*.pot
*.mo
*.gambas
main/gb*/gb*3
DISABLED*
.startup
.settings
.info
.list
.action/
.jit/
**/.gitignore
app/other/MakeWebSite/gambas.sourceforge.net/*/
*~
Hoe grafieken tekenen?
Er bestaat, naast SimpleCharts, al redelijk lang een nooit-afgewerkte eigen gambas-module om grafieken te tekenen, “gb.chart”. (nb: niet in OpenSUSE 15.1 default repo (gambas 3.10.0), wel in alternatieve repo community: home:munix9 (bv Gamabas 3.15.1) en ook in 15.2.
Maar daar is weinig documentatie of voorbeeldmateriaal over te vinden. Ik heb nu een (in een oude discussie op forum.gambas.one) een voorbeelprogramma gevonden dat wel inzicht geeft:
ChartTest
Op de Form is een DrawingArea geplaatst.
Het databestand wordt onmiddellijk in een array van strings geladen.
Chart wordt onmiddellijk aangesproken (dus geen hChart=New Chart of zo..)
De module heeft wel wat mogelijkheden:
Chart.Title.Text = , maar geen subtitel (iets kleiner onder de titel)Chart.YAxe.ShowIntervalLines=TrueChart.YAxe.Step = 10, of je kan de waarden onderdrukken mbv Chart.XAxe.Visible = False (dus niet de X-as wordt onderdrukt maar enkel de weergave van de waarde op die as)Opmerkingen:
Legend.Position, blijkt standaard 2 maar het is niet duidelijk wat je ermee kan doen; andere (+/- integer) waarden tonen de legende niet, ik dacht bv om ze in het vlak van de grafiek te zetten om plaats te winnen.Voorbeeld van gebruik met iets meer data: https://sourceforge.net/projects/garlic3/files/Examples/Gambas3Charts/
(Zie ook de praktische nieuwe project checklist en bij het programmeren de domme fouten checklist)
Enkele hulpmiddelen bij het starten van een nieuw project:
Leeg project
– Gebruik een sjabloon of een modelproject om van te starten. Het standaard leeg project van Gambas zelf bevat niets meer dan een startprocedure (methode), maar zelf zal je merken dat je telkens hetzelfde soort dingen er standaard insteekt. Denk maar aan een menubalk met File, Edit, Help/About/Changes/Licentie.. enz. Je maakt je eigen standaard leeg project met die menu’s er allemaal in, en dan kan je iedere keer daarvan starten. Je zet dat best online zodat je er van overal aankan. Je past het ook aan met de kennis en ervaring die verder opdoet, zodat het leeg project je steeds meer werk bespaart. (Voorbeeld “Emptyproject”).
Instellingen
Vrij snel merk je dat je allerlei instellingen wil bijhouden, zoals adressen van servers waarmee je verbindt, instellingen op het scherm van de gebruiker enz. Daarvoor dient de “settings” module van Gambas. Maar zowel het uitlezen van de settings als het bewaren ervan moet je programmeren, en die kunnen niet beide tegelijk klaar zijn. Met een “Gambas settings tool” kan je een nieuw settings bestand maken voor je project, met een scherm om snel de sleutel/waarde combinaties in te geven, er waarden inzetten zodat je ze al kan uitlezen met code, controleren wat je programma er in geschreven heeft enz. (Voorbeeld “Gambas Settings Tool”)
Vormgeving
Om de vormgeving een beetje te stroomlijnen kan je een form “Layout.form” maken waarin alle kenmerken voorkomen, bv de voor- en achtergrondkleuren van je schermen, de eigenschappen van de tekst, enz. Er hoeft geen code in te zitten, maar je kan wel zien hoe het er uit ziet op het scherm. Je zet er van ieder object een voorbeeld van op een scherm, (wel public zetten) en je applicatie neemt telkens daar de kleur, font, enz. van bij het openen van een nieuw scherm. (Zoals in Main.form bv een tekst die je initialiseert in FMain met txbx.Foreground=FLayout.txbxInput.Foreground). Als je dan je Layout.form aanpast, is heel je applicatie aangepast!
Databank
Ook voor de databank-koppeling kan je je laten helpen.
– Instellingen: door een vaste manier van databankgegevens op te slaan in de settings, met de mogelijkheid om te schakelen tussen je ontwikkel-databank (op je laptop bv), een test-databank op een testserver, en je productie-databank voor het uiteindelijk gebruik.
– Ontwerp: bij het ontwerpen van de databank komen bepaalde velden in tabellen telkens voor, zoals de id, het bijhouden van de datum van wijziging van een record, en de gebruiker die het wijzigde, een opmerkingen veld, enz. Met een tool kan je snel een nieuwe tabel maken, waarbij de standaard velden al voorgesteld worden op het scherm en je maar moet aanvinken welke je wil, en er bovendien automatische een data-dictionary bijdrage wordt gemaakt met mogelijkheid tot voorbeeld data en uitleg over de velden. (Voorbeeld: “DbInfoCode”)
– Ontwikkeling: bij het omzetten van objecten naar de databank of omgekeerd (persistence), van record naar objecten heb je ook telkens wat standaard handelingen als bewaren en ophalen van de inhoud van het object, het omzetten van de velden naar de properties van het object. Een hulpprogramma kan de velden van de records lezen en er objecten met properties voor maken, met de bijhorende get/set procedures. (Voorbeeld: “DbInfoCode”)
Opkuis
Om af en toe je programma op te kuisen, bv allerlei variabelen die je ooit eens maakte maar nooit gebruikt, kan je ook een hulpprogramma gebruiken dat de code voor je leest en op zoek gaat naar wat weg mag enz. Voor Gambas2 gebruikte ik daarvoor “ProbableCause”, maar nu is veel daarvan al geïntegreerd in Gambas3.
Door deze hulpprogramma’s zelf te programmeren kan je ze steeds laten evolueren met je noden. Zet ze online en schrijf erover.