As for resent release of Vala 0.39.4, there are huge improvements if we talk about warnings output at Vala code and C code compilation level.
One of the argument against Vala, has been the number of warnings you get for a valid Vala code at C level compilation. As an example you can check warnings for GXml in March 2017 about 230, some were my fault but other at C level.
Resent rebuilt in January 2018 for GXml shows a drop to just 9 warnings. But the extraordinary thing is that no C level warnings at all! Remaining warnings are for missing features in GIR format and one from Vala code.
Hope to find time to publish resent Vala improvements this 0.40 development cycle.
From this bug, reports a bug on using abstract compact classes with abstract methods. This is perfectly usable in GObject derived classes or GType based, but no for compact classes, they are not any of above.
Because is possible to add pointers to a struct, as GObject does, I’ve managed to create a patch to add support for abstract methods in compact classes. They provide pre-defined implementations with warnings outputs, as for GType/GObject based classes, and is possible to override them in derived classes.
Compact classes are really cheap on resources and construction, you can create really useful and easy to use C API from them and can be introspectable if you define methods to access your struct members.
If you want a fully and friendly bindable C library written in Vala, I recommend you to use non-compact classes.
This should start to demystify an old argument that Vala is just for GNOME. Vala for for GObject and GType based applications, no matter it is targeting Linux, Windows or OSX. Its productivity is great and no other language, to day, have same level producing GObject/GType based applications without overhead.
Writing a GTK+ custom widget with Vala is easy. First all create an XML definition with a top level container widget and a set of child ones. You can use Glade to do so. This is not a tutorial for Glade, so let start at with an already designed template UI file.
For this Glade UI file to be useful in this tutorial pay attention on:
- The top level widget’s type must be the same of the one your Vala class is derived from.
- The top level widget in your UI file must be declared as a template and should have the same ID as your class, this is the C name, a class called Cust.DateChooser, should be called CustDateChooser in order to allow Vala’s compiler to find its UI definition.
- The child widgets, to be controlled by your class should have an ID.
Take in account all these for following delivers.
Continue reading “GTK+ Custom Widgets: General Definitions”
GXml performance has been improved since initial releases.
First implementation parse all to libxml2 tree and then to a GObject set of classes, in order to provide GObject Serialization framework.
Over time GXmlGom was added as a set of classes avoiding to use libxml2 tree improving both memory and performance on Serialization.
GXml has been used in many applications like parse Electrical Substation Configuration Language files by librescl.org; to Mexican Tax Authority XML invoices format, among others.
For my private projects, I need to create QR of size 61×61 = 3721 squares. This means at least 2700 XML nodes. This is a large number of nodes and because QRSVG depends on GSVG and it depends on GXml, all them depend on GXml’s implementation for performance.
Initial measurements suggest that, at no surprise, using a simple array of objects takes up to 0.5 seconds to add just a node, as maximum time measured.
So GXml’s implementation should be improved for large number of nodes. Now it uses Gee.ArrayList, is clean and easy to wrap a node list implementing W3C DOM4 API. But now I’m considering to use Gee.TreeMap, because it is designed for large collection of objects, from its documentation:
This implementation is especially well designed for large quantity of data. The (balanced) tree implementation insure that the set and get methods are in logarithmic complexity.
The problem is its Map interface, where I need to implement a Gee.BidirList interface over it, in order to ensure fit in W3C DOM4 API and get performance boost.
Lets see how evolves this. Any suggestion?
While implementing GSVG, I had to add
DomDocumentType to a
DomDocument, so your renderer will recognize it is a SVG document, so I use following:
class GomNode : DomNode
class GomDocumentType : GomNode, DomNode
GomNode is implementing
DomNode, so yo don’t need to add that interface in its derived classes
Hours after a set of debugs, I found you should don’t do that, because it produce a infinite cycle, leading to a crash.
GomDocumentType should be:
class GomDocumentType : GomNode
GomDocumentType is a
At least for me, no SVG API is available as GObject API, so you have to deal with libxml2 library. On the other hand renderers are librsvg, but lacks API for SVG creation and Edition.
W3C has published an API specification version 1.1 for SVG and describes how renderers should interpret this XML document. W3C SVG depends on DOM as API to access XML documents.
While developing PLogic, I realized to have no way to create graphics for it, so take a look at GXml to dinamically generate SVG based on a logic diagram, using a GObject API to access XML documents. But no GObject API exists for SVG creation and edition.
Implement W3C API, is a matter to use OOP, like Java or C#, but a pain if you want to use pure C and GObject. So I choose Vala, because its syntaxis is very similar to W3C API and C#, making really easy to implement the API in a set of interfaces first and then in classes implementing those interfaces.
GXml lacks a good DOM support, due to liminations on libxml2 it relays on. So I started to implement a new pure GObject based set of classes, using libxml2 just for parsing and writting; they simple overcomes libxml2 limitations and now implements most DOM4, whitout transformations.
GSVG now uses GXml’s GomNode classes series, improving time to implement features in W3C specifications.
GSVG have pushed GXml ahead, by exposing bugs and requesting new DOM4 implementations in order to provide useful SVG documents.
Vala’s maintainers have worked really hard this development cycle. They have fixed lot of new bug reports in a very short time.
One of the biggest change is merging Valadoc as part of Vala. So, now
valadoc documentation utility will see official releases from the times to come, avoiding “drivers” for different Vala’s compiler versions.
Vala bindings for external projects, have been updated, including all resent Gtk+ 4.0 unstable API; bindings for
For details visit NEWS at Vala’s repository.
Maintainers behind Vala compiler, have been busy this cycle.
Vala has a continuous integration machinery, so new features are added to staging branch before to land in master, in order to check some Vala projects can be compiled and their unit tests pass.
Expect more Vala improvements, fixes and backports to 0.34 and 0.36, so you can use them in your favorite distribution.
While 0.34 haven’t been officially declared as a long term support branch, it has received most fixes and backports, so stable releases, like Debian upcoming Strech, can provide reliable, stable and improved experience to developers targeting GNOME 3.22/Gtk+ 3.22 stable releases.
Vala’s bindings using GIR format are updated constantly and because them can be generated automatically from project’s sources, new API additions/changes land in master really fast. Is the case of GTK+ 4.0 unstable; allowing you to create testing/prototypes using latest hot GTK+’s new features, using Vala.
For me, create GTK+ custom widgets is a very common task. Using templates for them, too.
Use GTK+ widgets defined by UI XML files, may be created by Glade, is a powerful feature.
Once you create your UI file, you should add it to a gresource XML file too, in order to use
glib-compile-resources to compile an embed, if you wish, in your binaries.
Once your project is big enough, you may fall in a large gresource XML file. Regenerate compiled resources based on resources changes, can be tricky, and a hand work.
So I’ve created
gresg, a tool to generate automatically an XML gresource file based in a list of files to be compiled with
glib-compile-resources. This will help you to trigger a rebuild of compiled resources at any time you make changes in your files.
gresg, is written in Vala and uses GXml to generate XML resources files. As you can see in gresg’s repository, is a very small program.
If you are using Meson you can create a custom target to generate your XML resources, but you need this patch applied to Vala to take all its advantages and automatic re-build of resources.