Settings[“sSlot/sKey”]=”value”

Terminologie
Een mooi voorbeeld van benoemen van de rubriektitels in het Settings bestand is “slot” en “key”. Slot is de titel, key is de variabele naam. Beiden zijn nodig om de waarde (value) op te vragen.
Ik probeer het bewaren van instellingen door middel van de module “Settings” een beetje te stroomlijnen, vooral in het kader van het bewaren van verschillende databank-toegang omgevingen waarin een gambas3 programma gedraaid wordt: ontwikkeling, test, ingebruik (development, testing, in production).

Veel van het gebruik van “Settings” zit vervat in deze code:

Dim sSlot, sKey as String
'
For Each sSlot In Settings.Keys
  Print sSlot
  For Each sKey In Settings.Keys[sSlot]
    Print sKey & ": " & Settings[sSlot &/ sKey]
  Next
Next

Een klasse kan helpen bij het beheren; bv CDataContext.

(wordt aan gewerkt)

Posted in Uncategorized | Comments Off on Settings[“sSlot/sKey”]=”value”

In memorial: Domotiga

Spijtig genoeg voor iedereen die met Gambas3 en Raspberry Pi werkt, is Domotiga al een tijdje verdwenen, ik schat van ongeveer 2015. De website www.domotiga.nl ging ergens in de zomer van 2015 (mei?) over in de site van CyberJunky’s Blog, alter ego van een zekere Ron “RDNZL”, de auteur van Domotiga. Die naam herken je zeker als je op de Gambas mailinglist ingeschreven was, daar was hij erg aktief meen ik mij te herinneren, en daarmee ook een aanwinst voor Gambas gebruikers in het algemeen.
Op CyberJunky vond je nog links naar Domotiga en DomotiYii, maar ondertussen lijkt er enkel een wordpress reklamesite van één of ander netwerk op de domeinnaam domotiga.nl te staan.

Ergens las ik dat de maker van Domotiga zelf overstapte op een ander systeem voor zijn domotica toepassingen (ok, dat klinkt erg onwetenschappelijk) – ik zie op de cyberjunky github pagina allerlei “Home-assistant” werk.. dat terug te volgen is tot december 2016. Home Assistant draait op Python.

Je vindt nog wel resten van Domotiga terug, bv in web.archive.org, waar je op de about pagina kan terugvinden dat Domotiga startte als een eigen versie van ‘Misterhouse”.

De laatste updates aan de Domotiga github repository vermelden (op dit moment) “May 16, 2019”, dus mogelijk draait het hier en daar nog wel…

Posted in Uncategorized | Comments Off on In memorial: Domotiga

Object-eigenschappen aanspreken

Ik ontdekte een niet backward-compatible verschil tussen Gambas3 versies:

In Gambas 3.14:

With Chart
  .BackGround = Color.Yellow  
  .Title.Text="Titel"
  With .XAxe
    .MinValue = 300
    .MaxValue = 900
  End With
End With

In Gambas 3.9:

Voorgaande code geeft een fout in Gambas 3.9: “Geen object in FMain:29”
Regel 29 bevat de geneste aanspreking van objecteigenschappen: With .XAxe
Die moet vervangen worden door With Chart.XAxe

With Chart
  .BackGround = Color.Yellow  
  .Title.Text="Titel"
  With Chart.XAxe
    .MinValue = 300
    .MaxValue = 900
  End With
End With
Posted in Gambas3 | Comments Off on Object-eigenschappen aanspreken

Grafiekenmodule in Gambas

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

  • componenten: gb, gb.chart, gb.form, gb.gui, gb.image
  • Projecttype: normaal
  • 0 modulen, 1 klasse, 1 form, 65 regels code
  • een “data” bestand met 7 lijnen van telkens twee cijfers, met komma gescheiden;

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:

  • type grafieken: Area (perc, stacked, symbols), Bars (perc, stacked), Columns (linecombination, stacked, percent), Lines (symbols, percent, stacked), Pie (Offset1, Offset2, Rings), Plots.
  • de titel kan opgegeven worden Chart.Title.Text = , maar geen subtitel (iets kleiner onder de titel)
  • de grafiek schaalt mooi mee in de hoogte en de breedte bij het wijzigen van het venster
  • de achtergrondkleur kan opgegeven worden
  • de horizontale lijnen kunnen aan/af gezet worden Chart.YAxe.ShowIntervalLines=True
  • de grafiekkleuren voor de dataranges kunnen opgegeven worden
  • je kan een legende zetten, met legende titel, en de kleurtjes van de grafiek, met label
  • Als er te veel waarden zijn op X en Y as (bv meer dan 200) worden de waarden van de as over elkaar heen gedrukt en zijn ze niet meer leesbaar. Je kan daarom een soort schaal zetten, bv Chart.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:

  • het is niet altijd duidelijk waarom iets niet werkt zoals je verwacht: begrijp je iets niet of is dat onderdeel niet klaar? De documentatie en/of de help is niet altijd volledig.
  • Legende: 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.
  • Geen subtitel
  • Als er veel waarden op een as van het type tekst (of datum) zijn, is het niet mogelijk om er af en toe een af te drukken, je kan ze enkel afzetten. En wat doet Autoscale T/F?
  • de DrawingArea in een Form laat niet toe andere elementen op die form te zetten; bv bovenaan een knop met kleurkeuze of zo, dan valt er onderaan een stuk van de grafiek weg. Misschien zal je dus in je FMain een apart venster moeten oproepen met de grafiek alleen.
  • het zou misschien handiger zijn een object te hebben ipv een module?

Voorbeeld van gebruik met iets meer data: https://sourceforge.net/projects/garlic3/files/Examples/Gambas3Charts/

Posted in Hoe - in Gambas | Comments Off on Grafiekenmodule in Gambas

Gambas 3 en Qt4, Qt5

Na updates van mijn OpenSUSE (van 42.3 naar 15.1) werken sommige applicaties die met Gambas3 gemaakt zijn, niet meer.

Het gecompileerde programma met link op de desktop lijkt te starten, maar sterft dan een stille dood.

Bij het openen van het project in Gambas3:

Sommige componenten worden gemist: gb.qt4.ext

Het probleem is waarschijnlijk dat er Qt4 specifieke componenten zijn gebruikt, en die zijn nu niet meer aanwezig of verkrijgbaar.

Test:
– project openen, ga verder en negeer de waarschuwingen van missende componenten.
– Project eigenschappen: vink gb.qt5 en gb.qt5.ext aan

Of:
– gb.gui.qt (QT4/QT5 switcher component)

Daarna nog:

Cannot load class “Editor”: Unable to load class file

En:
– gb.gui.qt.webkit (QT4/QT5 WebKit switcher component)

Maar dat blijkt niet alles op te lossen.

Unknown Control: Editor.

Gelukkig had ik 1 nog niet ge-update toestel waarop ik de oude versie kon openen.
Inderdaad werd daar een gb.qt4.ext object “editor” gebruikt dat code in kleur weergaf. Bestaat dat niet in qt5?

Ik denk dat ik in de oude opstelling de waarschijnlijke probleemobjecten zoals qt4 Editor er uit moet schrijven en checken of het dan wel werkt…

Daar zag ik dan in de help dat Editor “deprecated” is sinds 3.8 – “use TextEditor control instead”.

Na de vervanging van die control, en het overschakelen op de algemene gb.gui.qt werkte de applicatie terug.

Posted in Gambas3 | Comments Off on Gambas 3 en Qt4, Qt5

Terugblik naar Gambas3 in 2019

Nu er hier en daar wat stiltes vallen, is het een goed moment om de tekst eens te bekijken die de programmeur van Gambas, Benoît Minisini scrhreef naar aanleiding van het verschijnen van een nieuwe Gambas versie…

Gambas 2019 overzicht

De programmeertaal Gambas heeft vorig jaar achter de schermen een grote verandering ondergaan. De compiler van de programmeeromgeving is volledig herschreven.

In januari 2019 schreef Benoit Minisini een artikel voor de Franse linuxfr.org website. Het artikel sijpelde door omdat er naar verwezen wordt op de documentatiewebsite van gambas op gambas.sourceforge.net. Het kan beschouwd worden als een vervolg voor een stukje dat hij schreef in 2012 naar aanleiding van het verschijnen van Gambas 3.3, en dat ook op die site te vinden is. Ps: Sinds eind 2019 is Gambas aan versie 3.14.x., de zogenaamde versie “Pi”.

Gambas 3.12

Gambas is een programmeertaal die object oriented werkt en gebaseerd is op een basic-achtige interpreteerder. En het is ook een volledige IDE of programmeeromgeving met ondermeer een compiler, een interpreteerder, een verzameling van modules die complementair gebruikt kunnen worden, en een geïntegreerde programmeeromgeving. Het geheel wordt verspreid onder de GNU GPL v2 licentie.

Een nieuwe compiler

De grootste verandering bij de stap naar versie 3.12 is het afscheid van de oude compiler, die gebaseerd was op LLVM.
De API van LLVM voor het maken van code is een aantal jaar geleden veranderd van versie LLVM 3.5 naar LLVM 3.6. Hoewel het cijfer een kleine versiesprong aangeeft, blijkt LLVM 3.6 niet compatibel met de vorige versie, wat mogelijk de programmeur van Gambas ooit frustreerde, een probleem waar hij nu definitief van verlost wil zijn.

De nieuwe compiler is van het type “in vliegende vlucht” of in het Engels “on the fly” of ook wel “Just In Time”, met de bekende JIT afkorting.

De compiler vertaalt de bytcode van Gambas (in C) tijdens het uitvoeren, en gebruikt vervolgens de compiler van het systeem (meestal gcc of clang) om verder te vertalen naar de uiteindelijke machinetaal. Vladimir Makarov van de programmeertaal Ruby moet ongeveer dezelfde ideeën gehad hebben, en die zijn toegepast in versie 2.6.0 van de programmeertaal Ruby. (www.ruby-lang.org/en/news/2018/12/25/ruby-2-6-0-released/).

Deze methode heeft een nadeel: ze is trager dan de vroegere compiler. Maar ze heeft het grote voordeel niet afhankelijk te zijn van de API van de soms minder betrouwbare aanwezige C compilers. In tegenstelling tot de vroegere compiler neemt de programmeertaal nu de zaak helemaal in eigen handen. Meer nog, er kunnen nu bepaalde testen uitgeschakeld worden om aan snelheid te winnen. Maar daarbij stijgt dan het risico op het crashen van het programma, bijvoorbeeld door een onmogelijke deling door nul.

Door het gebruik van de nieuwe compiler doken er kleine probleempjes op na het verschijnen van 3.12, maar die werden de daaropvolgende weken snel gerepareerd in versies 2.12.1 en 3.12.2.

Webapplicatie met grafische interface

Een andere grote ontwikkeling van Gambas 3 is de mogelijkheid om web-applicaties te maken vanuit de programmeeromgeving, alsof je een klassiek desktop programma maakt.

Nieuwe component en gebruik van de programmeeromgeving

Die nieuwe mogelijkheid is gebaseerd op een nieuwe component “gb.web.form”, die kan omgaan met javascript notering, JSON formaten en URL methodes. Met “gb.web.form” krijg je een extra form, de WebForm. Dit type van Forms dient om de grafische schermen te definiëren die in je webapplicatie gebruikt gaan worden. Ze kunnen overeen komen met klassieke html pagina’s of dialoogvensters. De component biedt dan verschillende grafische controle-elementen om te gebruiken op je Form.

(hier een voorbeeld van zo’n form: op linuxfr.org)

Werking

Het principe van een webapplicatie verschilt grondig van een typische “Modale” toepassing. De webapplicatie wordt gecompileerd tot een cgi script dat daarna draait op de server, en niet op de desktop van de gebruiker.
De browser van de gebruiker dient als interface, een soort grafische terminal. Html wordt de beschrijvig van de interface.
Er wordt zo weinig mogelijk javascript gebruikt. De handelingen van de gebruiker worden onder de vorm van http/xml requests naar het programma op de server gestuurd. Die antwoordt met de nodige javascript code om de pagina te verversen. De toestand van de grafische interface van de gebruiker wordt bewaard in de sessie van de browser. Dat is natuurlijk veel trager dan webapps die voornamelijk in de browser draaien, en het biedt minder mogelijkheden, maar het werkt toch vrij goed.

(een voorbeeld van zo’n form op linuxfr.org)

Voor gambas ontwikkelaars heeft dat bovendien het voordeel dat ze kunnen werken voor een platform dat verschilt van hun eigen Linux computer, denk aan collega unix-achtige Mac, waar spijtig genoeg geen gambas op draait.

Welkom, Git

Er zijn ook wijzigingen in de ontwikkeling, het programmeren van gambas zelf. De programmeurs van gambas zijn overgeschakeld van het subversion systeem van Sourceforge op het Git broncodebeheer systeem. De referentieversie van de ontwikkelaars vind je nu op gitlab.com.
De hoofdontwikkelaar gebruikte een jaar en een half git om het te proberen, en hij vindt het krachtiger, sneller, gemakkelijker, en betrouwbaarder. Er is letterlijk niets tegen in te brengen.

Ook de mailinglist is overgebracht van SourceForge naar een prive-server die door een gambas gebruiker beheerd wordt.
Het systeem om foutmelding te beheren, de bug-list, wordt al langer beheerd met een eigen programma dat in gambas geschreven is, en draait op de server van de werkgever van de hoofdprogrammeur.
Nu zit enkel de hoofdwebsite nog op SourceForge, maar ook daar zal verandering in komen.

Nieuwe systemen

Er zijn naast GNU/Linux op x86 steeds meer andere systemen waarop gambas compileren al lukt :
FreeBSD
NetBSD
GNU/kFreeBSD
Cygwin

(maar dat betekent niet dat de hele IDE daarop draait zoals op Linux)

En de hardware breidt uit naar ARM, ARM64, PowerPC64.

Er werden ook aanpassingen gedaan voor Hurd.

Software platform

Gambas heeft ook een eigen platform om programma’s te publiceren die in gambas zijn geprogrammeerd. Je kan er gambas programma’s op publiceren en van afhalen. Dat kan van in de programmeeromgeving; je kan er de lijst van programma’s zien, filteren op categorie, en de programma’s installeren en de-installeren in je werkomgeving. En natuurlijk kan je je eigen project er aan toevoegen. Ook de voorbeeldprogramma’s die vroeger bij de IDE zaten, zitten nu in dat online systeem. De ontwikkelaar noemt het de “Logithèque Gambas”.

Programmeeromgeving

De IDE of geïntegreerde programmeeromgeving, het programma waarin je werkt om gambas programma’s te schrijven, is ook verbeterd, meer bepaald de beeldbewerkingsmodule. Die liet toe zeer eenvoudige pixelbewerkingen te doen, maar is nu volledig herschreven en kan nu veel meer:
Er is nu
– mogelijkheid voor meervoudige selectie.
– booleaanse operaties op verschillende selecties, dank zij een nieuwe component, gb.clipper (waarover later meer).
– rotatie en uitrekken en verdubbelen van selecties.
– selecteren via een toverstaf
– kleurbalans, helderheid, doorzichtigheid.
– kleurenpallet, kleurverzadiging, een kleur omzetten naar transparant
Kortom, het is een kleine gimp geworden.

Intrede van gitlab

De ingebruikname van Git heeft ook gevolgen voor de grafische interface, die vroeger enkel mogelijkheden had voor Subversion. De interface is dus aangepast om ook Git te kunnen gebruiken, tot en met de git branches. Maar niets gaat boven het gebruiken van de commandolijn voor het gebruik van git, want het programma heeft zoveel mogelijkheden die je niet allemaal kan uitwerken in de grafische interface.
Er is een Git menu bijgekomen met onder het menu Publier, Synchroniser, Annuler tous les changements, Tout ajouter au référentiel, en Branche, wat de andere takken toont. Je kan het je als programmeur niet beter wensen! Bij het gebruik van de commando’s via het menu krijg je een venster met de output van git, zoals je die normaal zou zien op de commandolijn.

Apart bestand openen

De programmeeromgeving kan nu gebruikt worden om een apart bestand te wijzigen, zonder dat je er een project voor moet openen. Je kan dus snel een beeldbestandje openen, of een SQLite database aanpassen. (ps Ik zie niet direct veel verschil met vroeger, want in Gambas 3.9.2 kon dat ook al)
Bij het starten van Gambas3 kan je kiezen voor Open Bestand, en dan krijg je bv alleen het tekenprogramma als je een pixel bestand hebt gekozen. Het lijkt op de File, Open file (Bestand, Open bestand…) die je kan doen als je in een project staat, maar dan komt dat bestand in de lijst bij de bestanden van je project te staan onder “File”, en je krijgt hem er niet zo snel weer weg (tip: delete verwijdert effectief het oorspronkelijke bestand!)

Modellen

Het venster om een project te openen is herzien: het baseert zich nu op een lijst van modelprojecten. Die lijst is naar hartelust uitbreidbaar. Het volstaat een nieuw project te maken in de verborgen map ~/.local/share/gambas3/template/ en dat zal mee opgenomen worden als nieuw modelproject. Standaard lijkt die leeg te zijn.

Gambas Lettertype

Er is nu een eigen lettertype voor Gambas beschikbaar. Als je wil kan je het installeren vanuit Gereedschap, voorkeuren, Letterypen (Tools/Preferences/Fonts). Met een knop wordt dan dat lettertype geinstalleerd in je persoonlijke map. Het bestaat uit Gambas9 en Gambas10, en van beiden een vet (bold) versie. Het zijn dus bitmap lettertypes met 9 en 10 punt groote. Het lettertype bevat heel wat unicode tekens, en hoewel niet helemaal volledig, toch bruikbaarder dan heel wat andere bestaande bitmap lettertypes.
Het standaard lettertype voordien hangt af van bv je distributie; bij Ubuntu zal dat bv “Ubuntu,11” zijn, in KDE “NotoSans,10”, enz (of ik zou ze daarnaartoe veranderd kunnen hebben).

Diverse verbeteringen

Een greep:
– mogelijkheid om een breakpoint te de-activeren
– gebruik van bestanden met het patch formaat
– de maker van de packages beheert nu de applicatie los van de grafische toolkit.
– automatisch aanvullen van de naam van bestanden
– de gewijzigde bestanden zijn automatisch bewaard bij het crashen van de programmeeromgeving
– het venster van het openen van een project is herzien
– de online hulp is te downloaden vanuit het opties menu voor offline gebruik
– de compressie van javascript bestanden en CSS is verbeterd
– PNG bestanden kunnen automatisch versleuteld worden indien het hulpprogramma pngquant aanwezig is. (ps: pngquant kan gemakkelijk bij-geïnstalleerd worden met apt get of via online zoek bij de paketten van je distributie, zoals software.opensuse.org; pngquant is a command-line utility and a library for lossy compression of PNG images)
– het beheer van donkere thema’s is aanzienlijk verbeterd
– het beheer van de sessies is onder handen genomen
– de interface van de debugger is herzien
– er is een venster voor het ingeven van speciale tekens
enz.

Toegang tot databanken

Het systeem voor de toegang tot databanken is verbeterd:
– de verbindingen gedefineerd in de instellingen van de programmeeromgeving zijn bereikbaar bij het uitvoeren van het programma, en de wachtwoorden die bewaard zijn in de portefeuille van de desktop kunnen automatisch gebruikt worden.
– de collation van de databankvelden wordt nu beheerd en worden in aanmerking genomen volgens het type van de onderliggende databank
– een klasse SQLrequest is toegevoegd, die toelaat om een SQL-request te maken die automatisch rekening houdt met de verschillen in syntax tussen de database systemen.
– de eigenschap Connection.LastInsertId laat toe om de laatste waarde van een toegevoegd record te krijgen bij een automatisch voortnummerend veld.
– de component gb.db.mysql laat toe sneller met mysql databanken te werken dankzij een interne cache van de meta-data.
– de component gb.db.sqlite3 laat toe met SQLite 3 databanken te werken en is volledig herschreven in C; ze is nu betrouwbaarder, sneller, gebruikt minder geheugen.
– de component gb.db.odbc kan nu een string verbindingsgegevens met ODBC ontvangen als hostname van de datanbank
– de component gb.db.form die grafische controle-elementen voorziet voor gebruik met databanken heeft een aantal verbeteringen gekregen.

Anderzijds biedt de databankbeheerder van de ontwikkelomgeving nu de mogelijkheid om de struktuur van een databank te bewaren bij het project. Deze struktuur kan nadien gebruikt worden bij het uitvoeren van het programma om automatisch de databank te maken (bij eerste gebruik) via de methode Connections.create().

De tekstverwerker component

De tekstverwerker met kleurcodering voor het programmeren is volledig herschreven in Gambas. Hij is geïmplementeerd in de nieuwe component gb.form.editor. Die tekstverwerker biedt alle mogelijkheden van de oude tekstverwerker, en brengt de volgende nieuwigheden:
– schuifbalken met vooruitzicht op de tekst (een beeld toont waar in de hele tekst je bent).
– automatische aanvulling van de aanhalingstekens; als je ze opent wordt er onmiddellijk een sluit-aanhalingsteken gezet. Ook voor het automatisch sluiten van haakjes en strings.
– meer kleuraanduiding voor de syntax
– automatische lijnoverschrijding (line break)
– smooth scroll
– duidelijk maken van de huidige controlestruktuur
– oplichten van de huidige zoekgeschiedenis

En aangezien de tekstverwerker geschreven is in Gambas, kan je hem gebruiken in GTK+ applicaties.

Terminal emulator component

De nieuwe component gb.form.terminal implementeert een terminal emulator controle, compatibel met de VT-100, volledig geschreven in Gambas. Hij laat toe aan de programmeeromgeving om de uitvoer van een programma dat draait, weer te geven in een echte terminal. (ps: ik denk dat deze uitvoer vroeger al onderaan het scherm voorbijrolde in een soort commandolijnbox)

Toegang tot kaarten

gb.map is een nieuwe component die toelaat om kaarten te gebruiken in een vierkantjespatroon, van OpenStreetMap, Google, Microsoft Earth en anderen.

De component biedt een klasse Map die een kaart voorstelt; met de mogelijkheid er een aantal vektoren bovenop te leggen. Hij biedt ook een controle MapView die zorgt voor de weergave van de kaart en die muisbesturing toelaat. De omvormingen tussen de verschillende projectiesystemen en de coördinaten worden beheerd door het hulpprogramma cs2cs van het project Proj.(ps: https://proj.org/apps/cs2cs.html)

Voorbeeld:

Public Sub Form_Open()
MapView1.Map.AddTile("OpenStreetMap", "http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", Null).Copyright ="© OpenStreetMap contributors"
'
' Centrer sur Paris
MapView1.Map.Center = MapPoint(48.866667, 2.333333)
MapView1.Map.Zoom = 5
'
End

Componenten Grafische interfaces
Grafische toolkits

Gambas gebtuikt altijd de grafische toolkits van Qt en GTK+, en biedt een identieke API voor de componenten van de twee toolkits, wat toelaat om een grafische toepassing te maken die op eender welke van de twee toolkits kan draaien. Een nieuwe component Qt5 (gb.qt5) gebruikt de bibliotheken van Qt5, terwijl een nieuwe component gb.gtk3 de bibliotheken van GTK+3 aanspreekt. Er zijn dus ondertussen vier grafische componenten die allemaal dezelfde grafische interface gebruiken in de programmeeromgeving.

Andere grote wijzigingen zijn:

  • – de standaard API voor tekenen is nu de klasse Paint, die implementeert een model gelijkaardig aan dat van Cairo; de functies om tekst op een lijn te zetten en schaduwen te maken zijn toegevoegd, alsook enkele nuttige tekenhulpmiddelen.
  • – vensters met alfa-componenten worden nu ondersteund
  • – de oude tegen-API GTK+ 2 is achtergelaten, en Cairo wordt overal gebruikt bij de GTK component.
  • – desktop sessies worden nu ondertsteund, de eigenschap Application.Restart laat toe om het commando te bepalen dat wordt uitgevoerd door de sessiebeheerder om de toepassing terug op het bureaublad te zetten bij het starten van het bureaublad.
  • – de ondersteuning van meer schermen is verbeterd (de dialoogvensters moeten verschijnen en centreren op het scherm van hun ouder-venster).

Frustratie no2

Iedere nieuwe subversie van GTK+ 3 bevat de onprettige verrassing om een deel van de softwarebibliotheek niet meer te zien werken. Het ging zover dat sommigen me hebben aangeraden om ze maar helemaal uit Gambas weg te laten.
Ik denk dat GTK+ 3 de slechtste softwarebibliotheek is die ik ooit heb moeten gebruiken, door de afwezigheid van terugwaartse uitwisselbaarheid.
Wat ik hoop: dat GTK+ 3 in werkelijkheid een doorlopende beta versie is van GTK+ 4, en dat in de toekomst alles in orde komt.

Herschrijven van de controle-objecten in Gambas

Heel wat interne controle-objecten zijn herschreven in Gambas, en werken dus op dezelfde manier in Qt of in GTK+. Ze zijn uitgevoerd in een nieuwe component gb.gui.base, die dient als basis voor alle code die in Gambas geschreven is en die gemeentschappelijk is voor alle grafische toolkits

Dankzij dat herschrijven en die doorgedreven gemeenschappelijke basis, is het mogelijk geworden om de volgende functies uit te voeren: afgedekte vensters vertonen nu schaduw binnenin, en ondersteunen nu een vloeiende afdekking.

Toevoeging van vele nieuwe controle-elementen:

  • – ColorPallette: een keuze uit kleuren van een kleurenpallet.
  • – DirBox: een tekstveld gekoppeld aan een mappenkeuze (nota: met een delete knopje voor het tekstveld).
  • – DocumentView: een controle-element die toelaat elk type document te tonen
  • – FileProperties: een controle-element dat de eigenschappen en de grootte van een document laat zien; de grootte wordt berekend in de achtergrond.
  • – FontBox: een tekstveld gekoppeld aan een lettertype kiezer.
  • – ImageView: laat toe een beeld te tonen met verschillende zoom-waarden.
  • – ListEditor: laat toe een lijst van elementen te wijzigen en opnieuw te sorteren.
  • – MessageView: een berichtenvenster dat automatisch verschijnt en verdwijnt.
  • – SliderBox: het samenbrengen van een Slider en een SpinBox, gelijkaardig aan wat bestaat in Gimp.
  • – Spinner: het tonen van een wacht-animatie in een vorm die ronddraait
  • – Spring: een map die uit een Panel spring, waarvan de eigenschap Expand True moet zijn.
  • – SwitchButton: een aan/uit knop

Beheer van de iconenbalk op de desktop

Het beheer van de iconenbalk is herzien. Het maakt gebruik van het DBus protokol van freedesktop.org als dat gevonden wordt. Daarbij maakt het automatisch gebruik van gb.dbus.trayicon. Anders, en zolang het ondersteund is door de desktop, blijft het X11 protocol gebruikt worden.

Frustratie 3

De ontwikkelaars van KDE, Gnome, en Unity zijn erin geslaagd om een gemeenschappelijk protocol DBus te gebruiken voor een iconenbalk. En die dan ieder op zich in een onderling niet uitwisselbare manier uit te voeren.

Daardoor werkt de iconenbalk via DBus enkel met KDE. Voor de anderen werken er sommige dingen wel, andere niet.

Eigen iconen

De component gb.form.stock biedt twee sets van iconen aan voor Gambas; één in monochrome of zwart-wit, de andere in kleur. Ze bestaan uit beeldjes van 32 op 32 beeldpunten, die automatisch worden uitgerokken naargelang de noden. Deze set iconen laat toe een toepassing te schrijven die niet afhangt van de iconen die al dan niet op het desktopsysteem aanwezig zijn.

Multimedia componenten

De component gb.media is momenteel gebaseerd op GStreamer 1.0. Zijn stabiliteit is grotendeels verbeterd, zelfs als alles nog niet perfect is, door -ondermeer- de breekbaarheid van de GStreamer API.

De volgende functionaliteit is toegevoegd:

  • – capsfilter is toegevoegd met filters voor Multimedia formaten.
  • – opvang van signalen die worden uitgestuurd door de GStreamer pijplijn.
  • – al lopend videobeelen opnenmen
  • – opvang van het laatste beeld van een pijplijn
  • – de mogelijkheid om twee stromen van multimedia samen te voegen in een ketting zonder knipwerk.
    Bovendien is er een nieuwe component gb.media.form die voorziet in een eenvoudige multimedia lezer in de vorm van een grafisch controle-element.

Scannergebruik

gb.scanner is een nieuwe component die als een omhullende werkt voor het programma scanimage van het SANE project.

Het nemen van een beeld gaat als volgt:

dim hImg as Image
hImg = Scanners["hpaio:/net/HP_LaserJet_MPF?ip=192.168.1.25"].Scan()

Alle opties van scanimage zijn bereikbaar via de eigenschap Option van ieder Scanner object. De mogelijkheid om meer pagina’s te scannen is voorzien via de asynchrone mode.

Netwerk component

En verder veel foutcorrecties aan de netwerkcomponent gb.net, zoals:
– de component gb.net.smtp, die het protocol SMTP beheert, is volledig herschreven in gambas. Hij is veel betrouwbaarder, en laat authenticatie als PLAIN en CRAM-MD5 toe, alsook SSL en TLS;
– de component gb.web.curl regelt nu het ftps:// protocol. Hij beschikt over een klasse HttpForm om gemakkelijk http pagina’s te kunnen verzenden, en een klasse DownloadManager om verschillende vormen van asynchrone downloads te beheren.
– gb.web.feed is een nieuwe component om de RSS stromen te beheren.
– gb.httpd is een nieuwe component die een eenvoudige HTTP webserver levert, en die wordt gebruikt door de ontwikkelomgeving om webapplicaties te debuggen die ontworpen zijn met de componenten gb.web of gb.web.form.

Multi-precisie berekeningen

De nieuwe component gb.gmp brengt Gambas de mogelijkheid om gehele getallen en rationele getallen te behandelen met een willekeurige precisie. Dit is gebaseerd op de bibliotheek van GNU: GNU multi-precision library. Het aantal getallen na de komma is enkel beperkt door de capaciteit van het systeem waar de berekening op draait.

https://gmplib.org

(Een voorbeeld is opgenomen in het origineel document)

Hulpcomponenten:

Twee componenten werden toegevoegd:
1. De eerste, gb.util, hergroepeert de methodes en praktische extenties van de interpreter.
– lezen van CSV bestanden.
– omzetten van datums van het Unix formaat of RFC822;
– berekening van de datum van Pasen.
– functies voor de creatie, verplaatsing en verwijdering van intelligente mappen.
– afstand tussen twee tekenreeksen volgens Damerau-Levenshtein
– tekst uit een stuk html halen
– uitfilteren van dicritische tekens
– omzetten van phonetisch (voor de Franse taal)

De tweede, gb.util.web, hergroepeert de methoden die nodig zijn voor het programmeren voor het web:
– omcoderen naar javascript
– de stroom van JSON coderen en decoderen
– URL verwerking

Andere nieuwe componenten

– gb.args is ee nieuwe component die dient voor het analyseren van de argumenten die meegegeven worden op de commandolijn vanaf hun beschrijving.
– gb.clipper is ee nieuwe component die gebaseerd is op de Clipper bibliotheek.
– gb.data implementeert nu de heap en PATRICIA boomstrukturen en een interface voor grafiekmanipulatie.
– gb.memcached is een nieuwe component die een memcached client implementeert (key-value db cache).
– gb.openal is een nieuwe component gebaseerd op de audio 3D bibliotheek OpenAL (OpenAL Soft waarschijnlijk, 3D geluid voor games en andere toepassingen)
– gb.openssl is een nieuwe component die een interface biedt voor versleutelingsfuncties van de libcrypto bibliotheek van het OpenSSL project
– gb.inotify is een nieuwe component die toelaat de mappen van het systeem in het oog te houden; het is gebaseerd op de inotify interface van Linux.
– gb.markdown is een nieuwe component die een lichtere vorm aanbiedt van de Markdown syntax.
– gb.report is vervangen door een nieuwe component gb.report2, die ook een verbetering is.
– gb.sdl2 en gb.sdl2.audio voorzien nu de SDL2 bibliotheek.
– gb.term is een nieuwe component die toelaat unix terminals te gebruiken, dichtbij wat het besturingssysteem aanbiedt.

Verbeteringen aan de taal

Nieuwe schrijfwijze (syntax)

– If … Then … Else … kan nu op 1 lijn gezet worden.
Match is een nieuwe operator die een vergelijking mogelijk maakt met een model (pattern matching), waarvoor het de bibliotheek gb.pcre gebruikt
– .[xxx] en !xxx zijn twee nieuwe afkortingen voor bewerkingen op arrays, te gebruiken binnen een struktuur van With … End With.
– het symbool … kan gebruikt worden om alle optionele argumenten van één functie naar een andere functie door te geven.
– numerieke constanten mogen in de octale notatie geschreven worden als &Oxxx (dus beginnend met de hoofdleter O);
– lokale variabelen mogen nu eender waar in de loop van een functie gedeclareerd worden, maar hun bereik blijft altijd beperkt tot die functie.
– het is nu mogelijk om variabelen van een lusstructuur te declareren bij het begin van de lus bij For en For Each, bv: For i As Integer = 1 To 100;
– het is nu mogelijk om onbeperkte toegang te hebben tot strings met arraybewerkingen.
– de compiler genereert een waarschuwing voor iedere lokale of globale variabele die niet geïnitialiseerd werd.

Nieuwe functies

– IsMissing() laat toe om de afwezigheid te checken van optionele argumenten
– Rand() geeft een pseudo willekeurig geheel getal
– System.Log() laat toe om in het systeemjournaal te schrijven (het is een interface van de syslog API van libc)
– Url() en FromUrl() laten toe om URL’s om te zetten.
– Move … Kill … laat toe om een bestand te verplaatsen en daarbij de atomaire bestemming te onderdrukken, onmisbaar bij het werken met processen die tegelijkertijd in hetzelfde bestand mogen schrijven.
– Assert laat toe om assertions (veronderstellingen) in de code te steken die het programma stoppen in geval van crash, ze worden niet gecompileerd tot het moment dat je een uitvoerbaar bestand genereert.

Correctie van de tijd-functies

De organisatie van de functies voor datum en tijd vertoont nu meer samenhang. Er is nu een duidelijke verdeling tussen functies die de lokale datum/tijd interpreteren en die met de universele UTC werken. Meer bepaald zijn nu de functies CStr() en CDate() nu uitwisselbaar, zoals het had moeten zijn van in het begin; het heeft wel de kost dat dit niet achterwaarts compatibel is.

Optimalisaties

– de functie Split() is sneller geworden
– de toegang tot arrays en collecties zijn sneller geworden, de benchmark voor “sort” is 25% verbetered.
– het grootste deel van de methodens Find() en Exist() voor arrays zijn sneller.
– de instructies Input en Line Input zijn sneller
– de omzettingen naar het type Boolean, en van of naar het type Variant zijn sneller.
– de ongelijkheidsoperatoren zijn sneller
– de functies Dir() en RDir() zijn nu 20 tot 40 procent sneller dankzij het gebruik van fstatat(), en door minder aanroepen naar stat() dan de intelligente gok van het aantal vaste linken naar de huidige directory facultatief maken.
– zoeken binnen een string is nu gemiddeld ongeveer vier keer zo snel.
– lussen met een variabele van het type integer zijn nu 5 procent sneller

Snelheidstesten

Hieronder de resultaten van een reeks van zes “benchmarks” die bestaan uit zes programma’s, geschreven in Gambas, Perl, en Python, waarvan de bron hier beschikbaar is (https://gitlab.com/gambas/gambas/tree/master/benchmark).

De gebruikte versies van de verschillende talen zijn:

Python 2.7.1.5rc1;
Perl 5.26.1;
Gambas 3.11.90 (ontwikkelversie van 2 november 2018)

Ze zijn uitgevoerd op een systeem met Ubuntu 18.04 met de Linux kernel 4.15.0-38-generic.
De tijden voor het uitvoeren van het programma zijn in seconden weergegeven.

… (op linuxfr.org staat een tabel met de resultaten)

───────── ───────── ───────── ──────────── ────────────────────────
Python Perl Gambas Gambas + JIT Gambas + JIT
(exécution uniquement)
─────────── ───────── ───────── ───────── ──────────── ────────────────────────
sort 3,93 6,36 4,76 0,84 0,25
polynom 9,94 13,40 8,04 0,84 0,75
primes 6,29 7,65 2,99 0,77 0,61
nbody 4,54 4,55 4,03 0,68 0,29
mandelbrot 5,34 4,24 3,06 0,22 0,10
string 8,94 1,81 1,41 1,49 1,40
─────────── ───────── ───────── ───────── ──────────── ────────────────────────

In vergelijking met de vorige testen kan men vaststellen dat er veel moeite gedaan is om de recente versies van er en Python te optimaliseren. Desondanks blijft Gambas aan kop staan in alle testen, behalve voor sort, waar Gambas na Python komt.
Men kan vaststellen dat de voordelen van een compilatie “in vliegende vlucht” ligt in de optimalisatie van de berekeningen, en dat die geen enkel merkbaar verschil oplevert in de behandeling van lettertekens (strings).

Conclusie

Er is de laatste 6 jaar veel werk uitgevoerd geweest, maar er blijft ook nog veel werk te doen:

  • – zelfs als Wayland nog altijd niet klaar is (integenstelling tot wat voorspeld was), zou er toch over gedacht moeten worden om het eventueel te overwege;
  • – aangezien Gambas ook werkt op ARM zou het goed zijn om te komen tot een werkende gambas op Android; er heeeft niets bewogen op dat gebied sinds vorig overzicht;
  • – de component gb.web.form verdient doorgedreven aandacht als de beste methode om web applicaties te maken in Gambas.
  • – het zou zonder twijfel interessant zijn om een andere taal dan BASIC te implementeren in de compiler.

Behalve enkele irritaties, die in de praktijk te maken hadden met vele verloren uren, te wijten aan (de fouten van anderen) bepaalde op te lossen problemen :-), kijken we met voldoening naar de evolutie van de taal. De mensen die ze gebruiken schijnen zelden teleurgesteld te zijn. Laat ons dus hopen, dat het jullie ook bevalt als jullie het uitproberen.

(En dan wenst hij nog een goed jaar aan alle gebruikers en ontwikkelaars van vrije software)

 ps: Dit is mijn eigen vertaling. Origineel in het Frans verscheen ondermeer op https://linuxfr.org/users/gambas

Posted in Gambas3 | Comments Off on Terugblik naar Gambas3 in 2019

Opkuis links

Spijtig genoeg zijn er een paar websites verdwenen, ondermeer die met de documentatie van de originele gambas2.  Ik heb de links nu verwijderd want de domeinnamen waren geregistreerd door anderen om willekeurige vissen te vangen….

  • title= Gambas Doc EN; “Engelstalige officiële documentatie”
  • title= Gambas Doc NL; “Nederlandstalige vertaling van officiële documentatiesite”

 Ook verdwenen of onbereikbaar:

  • Oude mailinglist op https://sourceforge.net/projects/gambas/lists/gambas-user

    Whoops, we can’t find that page.

  • Gambas playground https://gambas-playground.proko.eu/
    (server antwoordt niet)

en dan een paar nieuwe toegevoegd: gitlab en wiki.

Posted in Gamblog | Comments Off on Opkuis links

Nieuw project in gambas, hulpmiddelen

(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.

Posted in Databank, Hoe - in Gambas, vraag-me-af | Comments Off on Nieuw project in gambas, hulpmiddelen

gambas2020

2 in 2020?
Gambas3 natuurlijk, maar ook Gambas2 draait nog steeds op een huidige openSUSE Linux desktop die steeds bijgewerkt werd.
bv: Een OpenSUSE 15.1 heeft nog een Gambas2 versie: 2.24.0-2.1 uit Education/ openSUSE_Leap_42.2 repository (-nu buiten gebruik; daarom “rood” in Yast/Software management).
Daardoor kan je programma’s die nog niet omgezet zijn naar Gambas3 toch blijven gebruiken…

ps: in principe kan je ook je gambas2 project importeren in gambas3, en dan aanpassen waar nodig.

Kan je het ook nog nieuw installeren?

Distributies

  • openSUSE Tumbleweed: Gambas v 2.20.2, Repository: Community home:swyear
  • openSUSE Leap 15.1 en 15.2 : Gambas v 2.24.0 Repository: KDE:KDE3 Experimenteel
  • Er wordt op software.openuse.org nog een community versie vermeld voor Tumbleweed/Factory

    URL: https://download.opensuse.org/repositories/home:/swyear/openSUSE_Factory/
    Categorie: YUM

Dus in theorie kan het nog, weliswaar “experimenteel”.

  • Je kan proberen alleen de “runtime” te installeren, zodat je bestaande .gambas programma’s nog kan draaien.
  • Of waarschijnlijk moeilijker: de hele IDE installaren, zodat je gambas2 programma’s kan wijzigen/nieuw maken.

Maar in de praktijk is het niet zo eenvoudig….
Op een nieuwe installatie van 15.1 draait het (voorlopig) niet bij een gewone install van gambas2 uit de genoemde repo; ik volg mogelijk updates en geef in het 2.x update artikel aan met een (-) dat het nog niet veranderd is (zonder zelf extra dingen bij te installeren of linken).
Continue reading

Posted in Gambas2 | Comments Off on gambas2020

Domme fouten checklist

Af en toe loop ik vast en als ik na lang zoeken de fout vind blijkt dat bijna altijd een “domme fout” te zijn. Iets vanzelfsprekend waar ik over keek. Ik zou een kleine checklist moeten hebben om die stomme fouten er snel uit te halen.

Bv..

  • Aanroepen uit verkeerde module: bv een functie aanroepen met een verkeerde modulenaam ervoor ipv de interne, of gekopieerde brontekst waar nog een andere modulenaam instaat.
  • verkeerde veldnaam, vooral met dingen als id en/of employee_id
  • …(aan te vullen)
Posted in vraag-me-af | Comments Off on Domme fouten checklist