December 09, 2018

This week I was briefly in Berlin for the Qt World Summit, or QtWS for short. I was there to run the KDE booth as part of the exposition at the summit, rather than to do any talks (or, for that matter, watch any). First, a bunch of thanks are in order: to Sari and Milja from Moodboard for organising most of the things, to Katica from the Qt Company for doing PR on the show floor, to Kai and Roman from KDE for standing at the booth with me, and to the 700-or-so attendees for listening to us when we talk about KDE as a community, about KDE Frameworks and Plasma in laptops, tablets, phones and embedded. Thanks also to Paul and kde-promo for getting us some nice source material for stickers and shirts.

Photo of Kai and some laptops

Kai at the KDE booth at QtWS

The picture shows some of the stuff we did for the booth: a canvas banner, demo machines, and happy T-shirts. If the Italians (from a Sardinian argricultural-technology firm?) who wanted a T-shirt get in touch with me, we’ll make it happen.

One of the nice things about QtWS is meeting all the KDE people who have wandered away from the active KDE community, and are now inside the Qt Company, or KDAB, or all over the Qt ecosystem. KDAB, of course, gave a bunch of talks at the event and also contributes lots of code to both Qt and KDE; it’s still good to actually meet old KDevelop people and such. When talking to “old hands” is the fordness with which they talk about the community and participating in such a large Open Source project.

So the things we mostly talked about were KDE Frameworks — a fair subset of them are useful for small-footprint devices, embedded, automotive — and that Qt is Open Source. Reminder: Qt is Open Source. And so are all the things KDE builds on top of Qt. There’s a large number of very proprietary software companies around Qt in the automotive world. One really cool one does handwriting recognition, and does it well; I tested it in English, French, and Arabic with my untidy scrawl and its accuracy was pretty good. But .. no, not my cup of tea. The Pinebook got a fair amount of attention, but even more attractive to attendees was a prototype laptop that had been 3D-printed the day before. It looked like it had stepped right out of the 80s, but was running a pretty snappy Plasma desktop on top of mainline and Debian (can’t say more than that for now). We installed KDE neon on my Slimbook again, alongside openSUSE, to try out Wayland, and in particular gaming with Steam under Wayland. That .. turns out to work just fine, but people look at you funny when you’re playing CS:GO (please note my ambivalent and inconsistent treatment of proprietary software here) at the stand.

So, here’s to the Qt community and see you next time!

Continuing on this release month idea started last week, here is a release of another project. Today is the first release of qpropgen, a tool to generate QML-friendly QObject-based C++ classes from class definition files.

I started this project because I did not want to manually define the dozen of properties required to represent a sound in SFXR-Qt, which itself got started because I wanted a sound effect generator for Pixel Wheels. Yes, that's a bit of Yak shaving :)

It works this way: first you define your class and its properties in a yaml file:

class: Person
properties:
    - name: firstName
      type: QString
    - name: lastName
      type: QString
    - name: birthDate
      type: QDateTime

Then you run qpropgen person.yaml. It produces two files: person.h and person.cpp.

This is person.h:

// This file has been generated with qpropgen, any changes made to it will be lost!

#ifndef PERSON_H
#define PERSON_H

#include <QObject>

class Person : public QObject {
    Q_OBJECT

    Q_PROPERTY(QString firstName READ firstName
            WRITE setFirstName
            NOTIFY firstNameChanged
    )

    Q_PROPERTY(QString lastName READ lastName
            WRITE setLastName
            NOTIFY lastNameChanged
    )

    Q_PROPERTY(QDateTime birthDate READ birthDate
            WRITE setBirthDate
            NOTIFY birthDateChanged
    )

public:
    explicit Person(QObject* parent = nullptr);


     QString firstName() const;
     void setFirstName(const QString& value);

     QString lastName() const;
     void setLastName(const QString& value);

     QDateTime birthDate() const;
     void setBirthDate(const QDateTime& value);


signals:

    void firstNameChanged(const QString& firstName);

    void lastNameChanged(const QString& lastName);

    void birthDateChanged(const QDateTime& birthDate);

private:
    QString mFirstName;
    QString mLastName;
    QDateTime mBirthDate;
};

#endif // PERSON_H

And this is person.cpp:

// This file has been generated with qpropgen, any changes made to it will be lost!
#include <person.h>

Person::Person(QObject* parent)
    : QObject(parent) {
}


QString Person::firstName() const {
    return mFirstName;
}
void Person::setFirstName(const QString& value) {

    if (mFirstName == value) {

        return;
    }
    mFirstName = value;
    firstNameChanged(value);
}

QString Person::lastName() const {
    return mLastName;
}
void Person::setLastName(const QString& value) {

    if (mLastName == value) {

        return;
    }
    mLastName = value;
    lastNameChanged(value);
}

QDateTime Person::birthDate() const {
    return mBirthDate;
}
void Person::setBirthDate(const QDateTime& value) {

    if (mBirthDate == value) {

        return;
    }
    mBirthDate = value;
    birthDateChanged(value);
}

qpropgen comes with a CMake file to include in your project. Contributions adding support for other build systems are greatly appreciated :)

There is more to it: you can define read-only properties, make setters and getters virtual and a few other tweaks. You can learn more about qpropgen from the README.

Let me know if you find this tool useful!

Ya sabemos que las opciones en cuanto a lanzadores de aplicaciones para Plasma 5 está  más que cubierto pero lo cierto es que está más que bien tener más y más alternativas para personalizar nuestro entorno de trabajo. Hoy os presento Unibody Kickoff, el plasmoide número 95 de la serie que es una regresión visual del lanzador clásico pero con funcionalidades actuales.

Unibody Kickoff – Plasmoide de KDE (95)

Llevo un tiempo presentando lanzadores de aplicaciones alternativos para plasma 5. De esta forma ya ha pasado por el blog, entre otros, Tiled MenuSimple Menu, UMenu y Minimal menu.

Hoy quiero presentaros, Unibody Kickoff, el plasmoide número 95 descrito en el blog. Se trata de una miniaplicación para Plasma creada por Flipwise  y que nos ofrece una versión de uno de los lanzadores oficiales de Plasma, el clásico Kickoff, pero sin los cambios visuales que ha sufrido últimamente con la línea separadora o la caja de búsqueda.

Unibody Kickoff - Plasmoide de KDE (95)

 

Y como siempre digo, si os gusta el plasmoide podéis “pagarlo” de muchas formas en la nueva página de KDE Store, que estoy seguro que el desarrollador lo agradecerá: puntúale positivamente, hazle un comentario en la página o realiza una donación. Ayudar al desarrollo del Software Libre también se hace simplemente dando las gracias, ayuda mucho más de lo que os podéis imaginar, recordad la campaña I love Free Software Day 2017 de la Free Software Foundation donde se nos recordaba esta forma tan sencilla de colaborar con el gran proyecto del Software Libre y que en el blog dedicamos un artículo.

Más información: KDE Store

¿Qué son los plasmoides?

Para los no iniciados en el blog, quizás la palabra plasmoide le suene un poco rara pero no es mas que el nombre que reciben los widgets para el escritorio Plasma de KDE.

En otras palabras, los plasmoides no son más que pequeñas aplicaciones que puestas sobre el escritorio o sobre una de las barras de tareas del mismo aumentan las funcionalidades del mismo o simplemente lo decoran.

This week in Usability & Productivity, our flagship Kate text editor got a lot of love–and there’s more in the pipeline too! But that’s not all…

New Features

Bugfixes & Performance Improvements

User Interface Improvements

Next week, your name could be in this list! Not sure how? Just ask! I’ve helped mentor a number of new contributors recently and I’d love to help you, too! You can also check out https://community.kde.org/Get_Involved, and find out how you can help be a part of something that really matters. You don’t have to already be a programmer. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

If my efforts to perform, guide, and document this work seem useful and you’d like to see more of them, then consider becoming a patron on Patreon, LiberaPay, or PayPal. Also consider making a donation to the KDE e.V. foundation.

December 08, 2018

En ocasiones en los detalles se vislumbra realmente hacia donde se dirigen con más fuerza las  ramas de un proyecto. Y es que la Comunidad KDE tiene entre ceja y ceja su asalto a los dispositivos móviles que hasta sus creadores artísticos ya han empezado su particular aporte. Hoy me complace compartir con vosotros que Konqi y Katie ya tienen móvil con Plasma Mobile  con el que mostrar al mundo que la libertad en los smartphones es posible.

Konqi y Katie ya tienen móvil con Plasma Mobile

La semana pasada fue anunciado Necuno Mobile, la segunda colaboración de la Comunidad KDE en la creación de un dispositivo con Plasma Mobile con defecto. Que llegue a buen puerto ya es otra cuestión.

Lo que nadie negará es que la Comunidad KDE pone mucho empeño en que este sueño se haga realidad y una buena prueba de ello es que Tyson Tan , creador de la tercera versión de la mascosta de KDE y la primera revisión de Konqi, publicó recientemente un mensaje donde decía:

En otras palabras, Tyson ha incorporado una nueva versión de Konqi y otra de Konqi al extenso catálogo de imágenes de las mascotas de KDE disponibles. En ambas versiones destaca el uso de móviles, como podemos ver en la imagen inferior.

Konqi y Katie ya tienen móvil con Plasma Mobile

Las versiones de Konqi y Katie

Como se puede ver en la imagen inferior,  Konqi y Katie son dos mascotas muy polifacéticas y puede realizar muchas tareas como periodista, desarrollador, plasma, artista, de documentador, archivista, administrador web, ejecutivo, jugador, con corazón Qt, presentador, educador, científico, montador de hardware, jugando con la K de KDE,organizando Sprints para la Comunidad, configurando el sistema, con el logo de KDE, etc.

Más Konqis

Podéis descargar todos estos konqis y Katie en calidad profesional en los siguientes enlaces:

Un gran trabajo que todavía no ha finalizado y que bien merece nuestro aplauso y agradecimiento.

One obvious aspect of KDE’s privacy goal is eliminating all network connections that are not using transport encryption. That’s however not as straightforward to ensure as it may sound, it’s easy to have a long forgotten HTTP link in a rarely used dialog that should have been changed to HTTPS many years ago already. How do we find all these cases?

Scope

First of all, this is not about intentional or malicious attempts to bypass or weaken transport encryption at any level, but about finding our own mistakes. That is, simple typos forgetting the crucial ‘s’ after ‘http’, or legacy code from a time before the corresponding service even supported transport encryption.

This is also not about identifying servers that only offer weak or otherwise broken transport security, and communicating that to the user as we are used to from web browsers. All of that needs to be looked at too of course, but that’s a different task.

Source Code

Naively, searching the source code for http: and replacing it with https: would be a good start. However, it’s a bit more complicated than that, mainly due to http URIs being used both as resource identifiers and as addresses for resources. A common case for the former are XML namespaces, those are not actually retrieved via the network, so http URIs are actually not a problem (on the contrary, changing them might confuse the code dealing with them). In the latter case the URIs are actually URLs and are used for network operations, those we need to fix.

Still, a bit of crude grep work can turn up quite some useful results already. This can be clickable links in code (D16904, R209:33447a) or documentation (D17262), downloaded content (D7414, D17223) or access to online services (D7408, D16925, D16946). But many hits are part of code documentation, automatic tests or license information (R1007:aff001), which are less severe in their impact. Sometimes URLs also appear in translations, so those would need to be checked too.

Compiled Files

Another place to look for http: strings is in the compiled binaries. That’s less complete, but seems to have a much smaller false positive rate. A simple approach is grep-ing through the output of strings and strings -l e (the latter decodes 16bit little endian Unicode strings as used by QStringLiteral), and filtering out common URIs as needed in the source code search too.

Runtime Monitoring

An entirely different approach for identifying clear text connections is observing network activity at runtime. Tools like tcpconnect of the bcc suite seems to be a good starting point, as it allows continuous monitoring without noticeable impact, unlike e.g. capturing the entire network communication with Wireshark.

With this we can also find non-HTTP connections, as well as entirely unnecessary network activity (D7410, D7438). However, we wont notice anything from code paths that aren’t run.

Contribute

This is a perfect topic to get started with I think, fixing http: links is as easy as it gets, and yet that has relevant impact on the privacy or our users. But it doesn’t stop there, as we also need to build the tools to identify these issues more reliably. There isn’t much yet in terms of tooling, so a simple script would already be an improvement (e.g. to automatically check the KIO search provider desktop files), but if you are into elaborate runtime tracing techniques like used by the bcc tools, here’s a real-world problem to use this for :)

December 07, 2018

Nueva entrada ligera en el blog con una nueva ración  de temas de iconos. Os presento a Zafiro, unos iconos planos y mimalista con proporcionarán un toque elegante a vuestro sistema. Como es habitual, estamos ante una de las formas de personalización más completa ya que cambia totalmente el aspecto del mismo a la hora de interaccionar con tus aplicaciones, documentos y servicios.

Zafiro, iconos planos y minimalistas para tu escritorio Plasma

Os presento una interesante colección de iconos que viene de la mano y de la mente Zayronxio  y que nos proporcionará una gran pack de  personalización para nuestro Plasma 5.

Se trata de Zafiro un conjunto de iconos minimalistas y planos, con colores colores pastel que le otorgan un aspecto muy suave y pulido. El autor dice que los iconos son originales y no basados en otros, lo cual le confiere mucho mérito y es de agradecer.

Zafiro, iconos planos y minimalistas para tu escritorio Plasma

Los iconos se pueden instalar de la forma tradicional de “Obtener novedades candentes” o mediante el sistema de descarga del archivo zip y descomprimirlo en la carpeta ~/.local/share/icons (para solo un usuario) o en la carpeta /usr/share/icons (en modo superusuario para todos).

Y como siempre digo, si os gusta el pack de iconos podéis “pagarlo” de muchas formas en la nueva página de KDE Store, que estoy seguro que el desarrollador lo agradecerá: puntúale positivamente, hazle un comentario en la página o realiza una donación. Ayudar al desarrollo del Software Libre también se hace simplemente dando las gracias, ayuda mucho más de lo que os podéis imaginar, recordad la campaña I love Free Software Day 2017 de la Free Software Foundation donde se nos recordaba esta forma tan sencilla de colaborar con el gran proyecto del Software Libre y que en el blog dedicamos un artículo.

Más información: KDE Store

December 06, 2018

Cutelyst, a Qt Web Framework has upped to 2.6.0. This release if full of important bug fixes and is the best version when targeting Windows OS so far. It reached 5 years old, 440 stars on GitHub and since the last release has had many users asking questions, reporting issues and making pull requests.

Until now Windows support was a thing I mostly trusted Appveyor compiling and running tests fine, but this changed a bit in this release, I got a freelance job where some terminals would be editing images to be printed on T-Shirts, then they sent their art to a central server which receives and print, so, after I finished the QtQuick application and managed to convince them of running the terminals on KDE/Plasma as it was basically a kiosk full screen application I went on writing the server part.

Using Cutelyst on the server was a perfect match, the process was a Qt Widgets application, that, when linked to Cutelyst::WSGI could start listening all on the same process without issues, every terminal were connected via websockets protocol, which was just awesome, whenever I changed a terminal config I could see it changing instantly on the terminal, QWebSocketServer class could indeed do the same, but, to create the T-Shirt Art Fonts and Pictures needed to be “installed” on the terminal. Now with HTTP capabilities I simply exported all those folders and the whenever I sent a new JSON with config to the terminals, it contained the URLs of all these files which where updated in a blink.

On deploy time it was clear that using Windows on the server was a better option, first I’d need to give support for them on how to configure printers and use the system, also, printer drivers could also cause me troubles, so whatever let’s just compile it and get the money.

In order to make things easier I managed to get VCPKG to build a Qt5 for me, in a command line fashion, after that I saw how easy it was to create a package for Cutelyst, it’s upstream now, you just need to type:

vcpkg install cutelyst2

This will pull qt5-base package, and get you a working Cutelyst that easy, sadly Qt5 packages didn’t work on Linux nor on MacOS (both with issues filled).

Thanks to this project, several Windows related issues have been fixed, still work to do but I have an app on production on Windows now ��

I’m still no Windows fan, so I ended up configuring MXE and cross compiling Cutelyst and my application for Windows on Linux with it.

If you are doing embedded stuff, Cutelyst is also available on buildroot.

Besides that Cutelyst 2.6.0 has some other very important bug fixes.

Get it here!

It’s not uncommon to come across some dusty corner of KDE which hasn’t been touched in ages and has only half implemented features. One of the joys of KDE is being able to plunge in and fix any such problem areas. But it’s quite a surprise when a high profile area of KDE ends up unmaintained. www.kde.org is one such area and it was getting embarrassing. February 2016 we had a sprint where a new theme was rolled out on the main pages making the website look fresh and act responsively on mobiles but since then, for various failures of management, nothing has happened. So while the neon build servers were down for shuffling to a new machine I looked into why Plasma release announcements were updated but not Frameworks or Applications announcments. I’d automated Plasma announcements a while ago but it turns out the other announcements are still done manually, so I updated those and poked the people involved. Then of course I got stuck looking at all the other pages which hadn’t been ported to the new theme. On review there were not actually too many of them, if you ignore the announcements, the website is not very large.

Many of the pages could be just forwarded to more recent equivalents such as getting the history page (last update in 2003) to point to timeline.kde.org or the presentation slides page (last update for KDE 4 release) to point to a more up to date wiki page.

Others are worth reviving such as KDE screenshots page, press contacts, support page. The contents could still do with some pondering on what is useful but while they exist we shouldn’t pretend they don’t so I updated those and added back links to them.

While many of these pages are hard to find or not linked at all from www.kde.org they are still the top hits in Google when you search for “KDE presentation” or “kde history” or “kde support” so it is worth not looking like we are a dead project.

There were also obvious bugs that needed fixed for example the cookie-opt-out banner didn’t let you opt out, the font didn’t get loaded, the favicon was inconsistent.

All of these are easy enough fixes but the technical barrier is too high to get it done easily (you need special permission to have access to www.kde.org reasonably enough) and the social barrier is far too high (you will get complaints when changing something high profile like this, far easier to just let it rot). I’m not sure how to solve this but KDE should work out a way to allow project maintenance tasks like this be more open.

Anyway yay, www.kde.org is now new theme everywhere (except old announcements) and pages have up to date content.

There is a TODO item to track website improvements if you’re interested in helping, although it missed the main one which is the stalled port to WordPress, again a place it just needs someone to plunge in and do the work. It’s satisfying because it’s a high profile improvement but alas it highlights some failings in a mature community project like ours.

Facebooktwittergoogle_pluslinkedinby feather

KDAB announces the release of Kuesa™, a solution that provides an integrated and unified workflow for designers and developers to create, optimize and integrate real time 3D content in a 3D or hybrid 2D/3D software user interface.

Kuesa provides an easy, integrated and unified workflow without any compromises for designers and developers giving:

  • great performance on both desktop and embedded boards
  • high quality real-time 3D scenes
  • full expressiveness for designers, using professional 3D design tools
  • full control of integration for developers
  • reduced time to market.

For a practical demo, have a look at the tutorials created by KDABian Timo Buske, showing a complete workflow from the designer to the developer:

Kuesa is now available under both an AGPL and Commercial license. For more details about Kuesa and how to download it, visit the Kuesa web page.

Also, at this year’s Qt World Summit Berlin, KDAB’s James Turner will be giving a presentation on Kuesa titled, Streamlined Integration of 3D Content straight from 3DS Max and Blender into Qt3D. You can also view a demo of Kuesa at KDAB’s booth.

The post KDAB releases Kuesa™ for 3D asset creation and integration workflow appeared first on KDAB.

December 05, 2018

Since I find myself with a bit of down time. I have decided to update you all on the progress of atcore and atelier. We should hopefully be ready soon to start the process of releasing AtCore 2.0. I only have a few things I really want to get merged before I start that process. In the mean time here is what has been landed to AtCore since my last post.

  •  Allow for Reconnect without reset on unix hosts. (rizzitello, D13576)
  •  AtCore will now process Errors from the serialLayer (rizzitello, D15080)
  • Cleaned up Warnings from strict check. (rizzitello, D15861, D15701, D15280)
  • Allow for fractional movement. (i.e move X 6.84mm) (rizzitello, D15224)
  • New Axis Controller (rizzitello, D15281)
  • Use bit percentage for fan speed when needed. (rizzitello, D15700)
  • Use C++ Scoped enums (Cjlcarvalho, D16180)
  • Typo Fixes (yurchor, NO DIFF)
  • Header Typo fix (kbroulik, D17059)
  • Encapsulate the SerialLayer completely (rizzitello, D17146, D16200, D16199)
  • Fix Crash on reconnect on some cases. (rizzitello, D16616)
  •  Clazy Clang-tidy cleaning (rizzitello, D17101)

Atelier is getting more and more polish. Here is what has been landed to atelier since my last post.

  • Allow for Transforming Bed based on profile ( ervin, D16129 / rizzitello, D16144)
  • Check a file exists before attempting to print (laysrodrigues, D15122)
  • Remove Unaccelerated tooltips from lateral area (rizzitello, D16853)
  • Update new feeds as they are received (rizzitello,D16597)
  • QUrl.toString Not always valid (tcanabrava, D16002)
  • Clean up warnings (rizzitello, D16205)
  • Adjust icon size in lateral area for better scaling on a range of hidpi screens(rizzitello, D16855)
  • Prevent Error dialog if user cancels file selector (rizzitello, D17117)
  • Improve UI for mainwindow::askToSave(rizzitello, D17142, D17116)

 

December 04, 2018

Qt 5.11.3 is released today. As a patch release it does not add any new functionality, but provides important bug fixes, security updates and other improvements.

Compared to Qt 5.11.2, the Qt 5.11.3 release provides fixes for over 100 bugs and it contains around 300 changes in total. For details of the most important changes, please check the Change files of Qt 5.11.3.

Qt 5.11.3 contains the following important security fixes:

All these security fixes are included in the upcoming Qt 5.12.0 release.

Qt 5.9.7 released earlier contains all the fixes, except the one for virtual keyboard, which is available as a set of patches here, here and here.

Qt 5.6.3 release can be patched with these security fixes available here, here, here, herehere, herehere and here.

Qt 5.11.3 is the last release of the Qt 5.11.x series. The 5.11 branch is now closed. All bug fixes go into Qt 5.12 and the most important ones are cherry picked into Qt 5.9 LTS.

The recommended way for getting Qt 5.11.3 is using the maintenance tool of the online installer. For new installations, please download latest online installer from Qt Account portal (commercial license holders) or from qt.io Download page (open source).

Offline packages are also available for those can’t use the online installer.

The post Qt 5.11.3 Released with Important Security Updates appeared first on Qt Blog.

December 03, 2018

@tetris4 wrote:

Also available in Italian and Taiwanese Mandarin.

Hi everyone!

On your next system upgrade you will receive the latest versions of KDE’s Plasma, Applications and Frameworks, together with the regular package updates.

For more details and the full changelogs on KDE’s software releases, you can read the official announcements:

Other noteworthy package updates include:

[core]

  • ffmpeg 4.0.3
  • curl 7.62.0
  • openssl 1.0.2.q
  • apache 2.4.37
  • nginx 1.14.1
  • rust 1.30.1

[lib32]

  • steam 1.0.0.56
  • wine 3.21

[gtk]

  • filezilla 3.38.1

It should be safe to answer yes to any replacement question by the package manager application. If in doubt or if you face another issue in relation to this update, please ask or report it below.

Most of our mirrors take 12-24 hours to synchronize with the central repositories on the origin server. Use the mirror status web page to see when your mirror of choice last synchronized.

Enjoy!

Posts: 8

Participants: 5

Read full topic

As you might know, the QtQuick.Controls 1 module has been officially deprecated since Qt 5.11; this had been in the air already since quite some time, given that the development of the module had almost stopped. It looks like The Qt Company is mostly investing on the more performing QtQuick.Controls 2 module, and is inviting developers to switch over to that — at least for new projects.

However, there currently isn't a style available that would make an application using the QtQuick.Controls 2 look native on the desktop. There has been an attempt at it, but it soon turned into a custom style for the KDE desktop environment. So, some time ago I decided to give it a try: I started by forking the project of the KDE guys and as a first step I removed the dependency on the KDE libraries.

A button generated by the QML QQC2 desktop style
A traditional QPushButton
The difference (enhanced in Gimp, or you wouldn't see a thing)

It's a work in progress, and it probably has a long way to go before it's usable for a real world product, but I'm trying my best to turn it into something you can trust: this is a project where Test Driven Development fits very well, because in order to ensure pixel by pixel visual compatibility (that's my goal indeed!) I'm running a test where I create the same widget using the QtWidgets module and with this QQC2 style, and comparing the resulting surfaces for equality. In the pictures above you can see how the Button element looked earlier today (before I fixed it ��), compared to a traditional QPushButton: the test code creates a visual diff of the two images, and the test passes only if the resulting image is pitch black (with a very small tolerance for possible differences in font antialiasing).

For the time being I'm focusing my attention on the visual appearance of the individual widgets and their implicit size, but I'll soon add tests (and code) for layouts and interaction behaviours. I also need to extend the tests: they are currently run in GitLab CI for Linux only (where I can test the Fusion and the Windows styles), but I hope to find a way to run them in AppVeyor and on Mac OS. By the way, if someone knows of a CI service which would allow me to run my graphical tests on a Mac, please let me know in the comments.

This is an early notice that the project exists; if you have some time and energy to spare, you are very welcome to help me with the development.

Among the different cross-distribution application packaging systems available for Linux, the major ones being Flatpak, Snap and AppImage, I've chosen the latter for my own needs for the simple reason that it provides me the easiest way to ship my application and have it work out of the box. Flatpak and Snap will eventually get there, but for the time being universal availability and features like drag and drop are still to come.

However, the AppImage for PhotoTeleport is huge: due to having me ship many Qt5 modules, and especially the enormous QtWebEngine with all of its dependencies, the final package is almost 100 megabytes in size. One way to reduce that would be to require the user system to already have a Qt5 installation available, and therefore remove these libraries from the AppImage file. And if someone ran PhotoTeleport in a system where these libraries are not available, a small wrapper tool (based on xmessage maybe, and whatever Wayland equivalent exists) could inform the user of the problem and invite him to install the missing dependency. And I'm sure you certainly agree that this would be a horrible user experience: since we are so smart to tell that a dependency is missing, why not go the extra mile and install it ourselves?

Unfortunately, this “extra mile” is filled with subtle issues and there's the risk of delivering a solution that works in only a few lucky cases. For this reason, I would like to get the help of other developers and try to find a solution that takes into account all (or most) the subtleties that we need consider for different applications and target distributions. So, what follows is only the result of my initial brainstorming, and could be totally changed (or abandoned, if deemed unfeasible) depending on your welcome feedback.

Requirements

  • Smaller size: indeed, this is the whole point of this effort!
  • Optional: we don't want to make life harder for all developers: if you are happy with the size of your AppImage file, you should continue to be able to produce it the way you do now, and users should be able to continue to install it in the same way
  • Easy but not magic: installing the missing dependencies should be easy, but should not happen without the user's consent. At the very least, we must check that an internet connection is available and make sure that the user is fine with us downloading the extra stuff we need.

The UI problem

No matter how the solution gets implemented, we can be certain of one point: we'll need a way to show some UI to the user. At the very least, this would be a dialog box or a wizard, which would inform the user of what we are doing. We need to find a solution that works both on X11 and Wayland, and that is small enough not to totally destroy the size gain. xmessage is probably present in every Linux distribution, but there doesn't appear to be a Wayland equivalent that is as much available (wlmessage even seems to be unmaintained). Of course, the possibility of shipping whatever tool we need in the AppImage itself always exists and is indeed in the philosophy of AppImage, but then we need to consider how much this costs in term of size.

On the other hand, AppImage packages already assume that some libraries are present in the target system: the excludelist file in the AppImages project lists those libraries. Among them we find the XCB library (to create surfaces on X11 systems) and FreeFont (to render font glyphs), which should give us the possibility of creating some UI in X11; the wayland client libraries are not included, but on the other hand we are talking of less than 100 kilobytes. The next question is whether we want just rely on these libraries, and therefore do all the drawing ourselves, or make use of some other drawing library which would make our task easier. A simple drawing library such as libcairo is already 1 megabyte in size, and if we move to a more complete solution such as Gtk or QtWidgets, the size grows considerably (something between 10 and 20 MBs, from a quick rough estimation). I don't have an answer to this question, and I'd like to spend some more time investigating other options before jumping to code the installer and drawing it pixel by pixel. :-)

The possibility of having different installers, depending on the UI toolkit used by the application shipped in the AppImage (so that most of the dependencies can be shared), should also be considered. This would of course reduce the size gain — for a Qt application, for example, we would have anyway to ship QtCore and QtWidgets because the installer needs them — and would introduce additional complexity because we'd need to make sure that indeed both the application and the installer can work with the version of the toolkit we are shipping.

The developer story

Let's put the UI issue aside for a while, and think about how this could work from the application developer point of view. We have a bunch of dependencies that we'd like to take out of our AppImage; for example, Qt 5.9 with QtQuick and QtWebEngine, and OpenCV. Ultimately, the information we need to pass to the installer is the exact name of the libraries (like libQt5Core.so.5.9, libQt5Gui.so.5.9, etc.) as well as their soname as used by the application (like libQt5Core.so.5, libQt5Gui.so.5, etc.), possibly an md5 signature for each of them, and the URL where we can get them from, in case they are missing from the user system. Writing this information is boring, so the AppImage project might store some ready-made configuration snippets in its git repository.

An additional simplification could be the creation of “frameworks”: bundles of closely related libraries (for example, have a QtBase framework containing QtCore, QtGui, QtWidgets, etc. with all their dependencies).

The user story

When the user installs our AppImage on his system and launches the application, this will first execute the installer: the installer will check that all the downloadable libraries declared by the developer are present on the system, and if any of them are missing it would show its UI and guide the user to install them (here I figure a wizard-like UI, with progress reporting and asking as few questions as possible). The libraries would be installed somewhere in the user home directory, without requiring admin rights.

The installer story

This is where all the magic would happen, and where all the dragons are hiding. It's hard to describe all the complexity in a coherent text, therefore I'll just write down a bullet list of whatever passes through my mind (it's a brainstorming, after all):

  • The downloaded libraries should be stored somewhere under the user's ~/.cache/ directory: the reason is that AppImage does not have an uninstallation procedure, and we've always been telling users that the way to uninstall an AppImage application is just to remove the corresponding binary. So, given that the user will not know that he has to remove all the downloaded libraries, the most polite thing we can do is to put them in the cache directory, and hope that if the system goes short on disk space, somehow the cache directory will be cleaned.
  • The installer will add the location where the downloadable libraries are expected to be installed (for example, this could be ~/.cache/appimage/lib/<app-name>/) to the LD_LIBRARY_PATH environment variable.
  • The installer will check for the library presence in the directory above, by using their soname; if all libraries are found, it will start the application.
  • If some library is not found, the installer will look for it in the parent directory, ~/.cache/appimage/lib/, this time without using the soname but the full name; if found, a symlink will be created in ~/.cache/appimage/lib/<app-name>/ linking the library soname to the actual binary library. For example: ~/.cache/appimage/lib/MyApp/libQt5Core.5 -> ~/.cache/appimage/lib/libQt5Core.5.9.
  • If the library is not found there, system locations could explored, too. And again, a symlink would be created in ~/.cache/appimage/lib/<app-name>/. The application developer should be able to configure the installer to skip this step, in case it's known that some target distributions ship a version of the desired library that is somehow incompatible with the app (because the distro has patched it in some unexpected way).
  • If a library is not found at all, the installer UI shall appear, to inform the user that some libraries need to be downloaded. As the user agrees to proceed, the installer will download the missing libraries.
  • Are either of curl or wget installed by default on every distribution? It would be simpler to use them from a shell script, instead of using libcurl from C.
  • The library must be made available online. The developer could do that on his own website, and/or the effort could be coordinated among AppImage developers to create and maintain common repositories for open source libraries.

The way forward

While this is a lot of work, I don't immediately see a great complexity or any real blockers. The thing that scares me the most is the idea of writing the installer UI without using any comfortable UI toolkit. Do you see some other big issues that I haven't covered?

While I put more thoughts into this, I'm tempted to start an effort to solve this problem for PhotoTeleport only: the easiest way would be to write an installer program with QtWidgets, which is already a dependency I'm shipping, and have the installer take care of downloading QtDeclarative, a few other QML modules and QtWebEngine. I could write it in such a way that it would be reusable at least for other Qt-based AppImages, and on the other hand this could be a proof of concept to tell whether this whole idea is feasible or not.

Just to highlight it: I wrote that I'm tempted to play with this idea; whether I'll do it for real is all another story. :-) I'm still pondering whether the whole thing is worth the effort, given that I haven't received a single complaint from users so far.

I already wrote about PhotoTeleport in my previous post, but since not everyone can comfortably read interlingua, here's the English announcement


I've spent the last few months of my free time to work on a new application, called PhotoTeleport, which is a photo uploader capable of working with multiple photo sharing services at once.

It's an application I myself felt the need for, because as a photographer I keep my portfolio in many websites: I have a couple of pages in Facebook, and VK (a.k.a. "the Russian facebook"), but I also have a profile in other websites such as Flickr and DeviantArt, which I created to further promote my activity, but which alas I failed to keep up-to-date. The harsh reality is that working with multiple profiles is hard: even if you had just two profiles to maintain, it takes a lot of time to upload the photos to both of them and, no matter how convenient their user interface is, entering captions, descriptions and tags here and there is another boring, repetitive and time consuming task.
Then how about automating it? Enter PhotoTeleport, and all photographers rejoice!

The program in itself is very simple: you drag and drop the photos into its window, select which services you want to upload them to, add captions, descriptions and tags (if you like), review and then upload. For those who prefer a feature list in bullet points, here it is:

  • Support many photo sharing services: DeviantArt, Facebook, Flickr, Google Photos, VK, etc. (see here for an updated list)
  • Album selection, or creation of a new album (if the service supports it)
  • Fast editor for captions, descriptions and tags
  • Possibility to specify different captions, descriptions and tags for each website
  • Read metadata embedded in the image files
  • On upload completion, provide a link to the newly uploaded files for additional editing or sharing

This is just a beta version, but more features are planned, including:

  • Ability to save and restore session
  • Watermark support
  • Image scaling
  • Support for more plugins (500px, Imgur, Smugsmug, Shutterstock, Photobucket, Pinterest and more)
  • Support for uploading to a custom (S)FTP server

You are indeed welcome to suggest new features, just by adding a comment to this blog post, or by creating an issue in the PhotoTeleport bug tracker.

PhotoTeleport is available for Linux, MacOS X and Windows; to get it, please visit PhotoTeleport website.

Only for the geeks and the folks from the IT crowd

Here's some info for those who desire to hack on PhotoTeleport, or just to know more about the technology behind id: PhotoTeleport is an open source project, it's written in C++ and QML using the cross-platform Qt framework. The authentication to the remote servers is handled by libauthentication, a library that I wrote just before starting the work on Phototeleport to provide an easy way for Qt and QML based applications to authenticate and peform authorized requests to remove websites using the OAuth 1.0 and OAuth 2.0 protocols (other protocols can be supported too).

Linux users might ask me why I chose to ship PhotoTeleport as an AppImage package, rather than using Flatpak, Snap or a native distribution package like deb or rpm. This might deserve a blog post of its own, but in brief:

  • deb> or rpm: they require root permissions to be installed, moreover PhotoTeleport uses Qt 5.9 which is not available in all distributions, so if I have to bundle Qt with my package, I don't see many advantages over shipping an AppImage;
  • Snap: they require root permission to be installed, and the support for desktop applications is still incomplete;
  • FlatPak: there's no runtime for Qt applications (and no, I don't want to force users to install the whole KDE runtime!), and drag & drop is not supported yet.

That said, it's just a matter of making the best out of my little spare time. I can reach every Linux user with the AppImage format, so that's the first option I took. I'm certainly open to the idea of using also other formats in the future (I might make debs after Ubuntu 18.04 is released with Qt 5.9) and I'll happily accept any contribution that can make PhotoTeleport available in Snap, Flatpak or other formats. But I don't have the time pioneering that right now :-)

Everyone who has used the QML programming language should love its property binding mechanism, which is made very easy to express via its declarative paradigm:


import QtQuick 2.0

Column {
  TextEdit {
    id: inputField
  }
  Text {
    id: secondLabel
    text: "You typed: " + inputField.text
  }
}

If you have worked on a project where QML was used along with C++ code, you might have bumped into a scenario where some bindings don't seem to work as you'd expect:


import QtQuick 2.0

Text {
  text: cppModel.get(row, "description")

  MyCppModel {
    id: cppModel
  }
}

Whenever the value of the row variable changes, the property binding is re-evaluated and the text is correctly updated; however, if row is not changed and it's only the cppModel contents to change, then you'll be out of luck: the text won't update accordingly.
This apparently unexplicable behaviour has in fact an obvious explanation: the QML engine re-evaluates the property bindings only when a variable appearing in the expression (or in a javascript function used in the expression) is modified. But since in this case the function get() is a C++ method, the QML engine is not aware of this method's internals and does not see any change requiring refreshing the binding.

The first thing we have to do in order to solve this problem is to find a signal which tells us when it's time to re-evaluate the bindings. If you are working with a model derived from QAbstractItemModel, then you probably want to bind to the dataChanged signal, or maybe modelReset (if you simply reset the whole model when updating it). In the general case, your C++ class should have a signal or a property which gets updated when needed. If not, add it! :-)

The trick I've been using in some occasions is then to artificially trigger a change in a property used in the binding, in order to force the refresh:

import QtQuick 2.0

Text {
  text: cppModel.get(row, "description")

  MyCppModel {
    id: cppModel
    onDataChanged: {
      var tmp = row
      row = -1
      row = tmp
    }
  }
}

I know, I know, this is horrible. It works, but it causes the expression to be re-evaluated twice, since we are changing the row property twice. Besides, chaning the row property might have some unwanted side effects in other objects, if this property is used in other property bindings. And what if the C++ method doesn't take any parameters at all? How can we trigger its re-evaluation then?

I recently came up with another solution, which is the reason of this blog post. And yes, it's still a hack, but an elegant one. It uses the rarely used comma operator, which in Javascript works in the same way as in C++: it evaluates all operands, and returns the value of the last one. So, this is what we can do:


import QtQuick 2.0

Text {
  text: cppModel.updateCounter, cppModel.get(row, "description")

  MyCppModel {
    id: cppModel
    property int updateCounter: 0
    onDataChanged: updateCounter++
  }
}

Note that we've added an extra property, updateCounter, which we'll change whenever we want the binding expression to be re-evaluated. In this case I've added the property to the QML component, but if you own the C++ object you could add it to your C++ object. And of course, if your C++ object already has a property which gets updated when you also want to update the binding, then you can use that instead: it can be of any type, it doesn't have to be an int.

I hope you'll find this tip useful. :-)
Mappero has always been distributed under a GPL licence. However, since when I started selling Mappero Geotagger (which is built from the same source), I decided not to publish the source code in a public repository, but only to provide it to those who made an explicit request to obtain it.

I spent some time reconsidering the matter, and I've finally decided to let the source code live in a public repository. I also setup a mailing list for it. And indeed I welcome code contributions, however there's a small catch: a CLA. While Mappero is distributed under the GPLv3 licence, I request that all contributors send me an e-mail in which they give me the right to re-licence their contribution under any licence published by the Free Software Foundation.

Since I believe that the busiest time for my involvement with speculo has passed, I expect to be able to spend some more time developing Mappero. The qt5 port is more or less working, but most of the cool features are missing, so it's little more than a map viewer at the moment (Mappero Geotagger, however, is fully working under Qt5!).

Here you can see Mappero running on an Ubuntu Touch powered Nexus 4. Pinch zooming and GPS are not yet working, but I promise they'll be there in less than a week. Also I found a nasty bug which can cause the application to crash when downloading map tiles, and I'll fix it ASAP (I'm mentioning it just so that I won't be flooded with identical bug reports now :-) ).
Io es felice de annunciar que io ha publicate QtRaw, un plugin que permitte a tote programmas que usa le librerias Qt (e consequentemente, QML) de aperir e visualisar imagines in formatos raw; istos es le imagines producite per multe photocameras digital professional e semi-professional.
Si on vole visualisar le imagine in un formato reducite, le plugin utilisa le imagine de prevista (thumbnail), lo que es multo rapide.

E nunc io va; le prandio de Natal me attende. :-)

I decided to blog about my experience of transitioning from being a GLib and GObject enthusiast to a Qt (and QML) fanboy. :-) I'm not writing this with any specific goals, other than sharing my own experience and hopefully making the life of those developers who are forced to learn and use Qt less painful and a bit more rosy; in particular, I'm not trying to be a Qt evangelist here and convince you, hardcore GObject developer, to switch to Qt: I'm indeed sure that if my current self tried to talk my 3 years younger self into Qt, it would be a useless and tiresome (and maybe violent ;-)) discussion.

Just a bit of background on myself: I've been developing on Linux and Unix for more than 10 years now, mostly using GObject based libraries, such as Gtk+. I had a short encounter with Qt in about 2004, just for a few weeks, which left me with a bad impression (mostly because of the uic). Other than that, I was simply not interested in Qt, mostly because I hate C++ and love C and anyway all my needs were perfectly met by GLib, GObject and Gtk+. I remember that the first time when I read about GObject, I was fascinated: the power of OO programming on top of my favorite language, all open source and hackable. In autumn 2006 I started a new job in Nokia, in the maemo team, working on a middleware component in the Telepathy VoIP framework; I enjoyed it a lot, and (if possible) grew even more fond of GObject and GLib. On early 2008, the big news: Nokia acquires Trolltech (the SW house developing Qt); for me, as for most of the people working in the maemo team, this came as a complete surprise, and not as a really good one. Indeed, we were afraid that we would have to abandon the C/Gtk+ work and switch to C++/Qt — perhaps not coincidentally, several GNOME developers working in Nokia even left the company around that time. Luckily though, nothing really changed for us for more than one year, and even later, when more people joined to work on Qt-related stuff and I moved to another project, I could still avoid touching Qt code and continue using only my beloved GObject. However, like all good dreams, this also came to an end: eventually, I had to refresh my C++ knowledge and change my most typed character from "g" to the hated "q".
So, here my Q story begins.

The first prolonged exposure to Qt

It was painful. My first task was to create Qt-bindings for the GLib-based library I was developing. There was no UI involved, so on the tools front the experience was not as bad as I remembered; but on the pure programming side, I was horrified: I felt extremely limited, many programming paradigms I was used too couldn't be applied, or I was just told (by people more expert in Qt) that “you shouldn't do like that, it's not the Qt way!”. Urgh.

The biggest issues I had were the lack of reference counting in QObject (!!) and the veto on using C-style function callbacks for asynchronous operations (you should use Qt slots, and in order to have a slot you must have a receiving QObject). How could I take Qt seriously? Sure, there were also a few nice things about it, like the fact that QObject comes with child-parent lifetime handling out of the box (when a parent object dies, all of its children are automatically deleted), and that signal connections are automatically broken when either the emitter or the receiver object dies (yay, no more explicit signal disconnections — or random crashes!). But still, this could in no way compensate for the lack of the other low-level features I was used to.

I cannot really say that I enjoyed the first months of using Qt. I was still trying to work as much as possible on the GLib-based parts of the project, and twisting my head around to figure out what was “the Qt way” of doing all the things that I was used to do almost instinctively with GLib/GObject.

From hate to love

Now that I think back and try to find the moment of time when I finally started liking Qt (or just not dislike it too much), I cannot really point out a definite time. It was a very slow process, that surely wouldn't have completed if I hadn't been forced to use Qt because of my work. But indeed, the moment when I realized that Qt was not so bad after all is when I started writing new original code with it. In retrospection, I would say that my experience with Qt was so bad because I started with a completely wrong task: as an inexperienced Qt developer, creating binding for a GObject-based library couldn't possibly make me appreciate Qt; I was just bound to notice all the GObject features that were not present in Qt, and suffer their absence. And I wouldn't notice almost any of the niceties that Qt offers to application developers, because there is not much code you can write in a wrapper library other than some trivial glue code.
So, my first suggestion for those GObject developers who start using Qt is: do not write a Qt wrapper to your favorite GObject library!, you are going to hate it. Leave it to someone who is more experienced than you in Qt; it can be a very pedagogic task, indeed, but chances are that it will be the last time you are going to use Qt. If you can, start with writing new code.

That said, there is a big difference between not disliking something and loving it. But again, I cannot tell when I started loving Qt. What I surely can tell is when I realized that I loved it: and that was when I started porting some GObject-based code to Qt (not as a line-by-line port, but more like a functional rewrite) and found out that the resulting code was not only more compact and easier to write, but — and especially — easier to read. And of course, when I realized that my enthusiasm was not the same as before, whenever I had to do some programming in C+GObject.

What I find cute in Qt

Let me begin with a couple of statements which could dispel some myths or anyway clarify some doubts that the Qt-virgin might hold:

  • It's not C++. This is a bold (and false) statement, but it's probably the most effective to convey the idea: if you — like me — hate C++, you won't necessarily hate Qt. Qt's C++ is a subset of C++: although you can use whatever C++ feature you might like, developing with Qt does not involve using exceptions, templates, RTTI and the STL. In a similar way to how GLib and GObject “extend” the C language, Qt uses a preprocessor (called moc) to add its own run-time type information (think of GType) and implement the signals/slots mechanism. In the end, you don't need to know all the details of C++ to develop Qt; instead, it's somehow similar to developing Vala code — it's like a programming language of its own.
  • It's not just GUI. As you might have noticed, this post is not about Qt vs. Gtk+, not at all. There are many other articles on the web where you can find comparisons and opinions of the two, but what I'm focusing on here is my experience with Qt programming and GNOME programming, and not just at the UI level. So, yes, the point is that you can develop whatever code with Qt (except maybe kernel drivers): I've personally written D-Bus services, command line tools and embedded software using just Qt.
  • There really is a Qt way. My disappointment about the lack of reference counting in QObject is now history: apart from the fact that indeed there is one class in Qt which lets you implement reference counting for QObjects, I cannot recall any case where reference counting would have been useful. I know, coming from GObject this might sound hard to believe (especially to my three years younger self, who used to mess up with cross references everywhere in the code), but it's a fact: after some initial struggle, I always managed to design the software with clear ownership of objects, so that the reference counting ended up to be totally superfluous. And in fact, my code is designed better now. The same can be said of any other feature that I initially missed: if it's not there, you can do without it: just restructure your code in a different way — the Qt way — and there's a good chance that while reworking your classes you'll clear up some mess. :-)

That said, here's a list of things that I came to like about Qt; I'm obviously not mentioning those things that are also in GLib/GObject, unless there are significant differences.

  • QObject automatic destruction of children. I already mentioned it before, but it's worth expanding a bit. Quite often I had to use reference counting in my GObject subclasses to keep track of the child-parent relationships; QObject already does that for you: whenever you create a QObject, you can specify one parent object which will “watch” its lifetime and destroy it in its destructor. This leads to a nice programming paradigm where you can create all the objects that your class needs and just use the this pointer as parent object: then you don't need to remember destroying them explicitly in your destructor.
  • Automatic disconnection of signals when receiver object dies. I also mentioned this before, but repetita iuvant: if you are an experienced C + GObject developer, you must have seen at least once in your programming career one crash due to a signal callback invoked when the objects it operated on had already been destroyed. Of course I know that it never happened to you personally, but you surely saw this in someone else's software. ;-) Well, in Qt this is very unlikely to happen, because (at least till Qt4) it's impossible to bind signals to C callbacks: you must bind them to a QObject method (called “slot”), and the QObject system takes care of disconnecting the signal for you when either the emitter or the receiver object are destroyed.
  • QString. I'm sometimes a bit maniacal with micro-optimizations, and one thing I was always trying to optimize in my early GLib days was avoiding string allocations. It really hurts me to write a g_strdup() in a library method's implementation when I could rather write "Please, don't destroy or change @string_param while this object is still alive" in the documentation string for the method. But that's not the GLib way (and indeed, not my way anymore when I write GLib code): you can never know what happens with the string, so it's way safer to incur the small penalty of a g_strdup() than run the risk of a crash which is likely to be very hard to debug. So, C/GLib code is often full with g_strdup() and g_free() (not to speak about valac-generated code!). Enter QString! QString is not only a class that provides a ton of useful string methods, it is an implicitly shared class. That means that the QString structure itself is very small (size of a pointer?), and that the string data is reference counted; then if/when you modify a string which has a reference count higher than 1, the string data is copied and your QString is now pointing at the modified copy. So you never have to worry about copying strings! How cool is that? :-)
  • Awesome container classes. Qt comes with a few container classes which you'll surely get to like: QMap, QList are those that you'll use the most, but then there's also QSet, QQueue, QHash, QVector and others. These are template classes, so you can write QMap<QString,QVariant> and get the equivalent of a GHashtable whose keys are strings and values are GValues. Inserting items is as easy as writing
    QMap<QString,QVariant> map;
    map.insert("string", "string value");
    map.insert("integer", 12);
    
    while to iterate the values you have the handy foreach macro, which lets you write
    foreach (const QVariant &value, map) {
        QDebug() << "Value:" << value;
    }
    
    And if you remember what I wrote above about QString: Qt container classes are implicitly shared too!
  • Reduced usage of pointers. This follows in part from the above: QString handles all string pointers for you, and the ease of implementing implicit sharing of container classes makes it so that you will be often passing them by value or by reference. Also, implementing implicit sharing for your own data structures is very easy, and you might prefer investing a little time doing that rather than using raw pointers.
  • Class and API offering. Even excluding the GUI classes, the functionality provided by the Qt classes will satisfy the most demanding developer: whether you want to deal with date/time, with network resources, with graphics/images, HTML (webkit), SQL databases, D-Bus, plugins, regular expressions, etc., it's all there, and everything works perfectly together. The APIs are intuitive and clean: you won't find duplicate classes offering the same functionality (unless one is deprecated), and the documentation is excellent.
  • Compact and clean code. Qt application code is likely to be much mode compact and clean than GObject code. Just like Vala, imagine removing all GObject casts and using class namespaces to shorten your method names and fit your code in a 80 chars wide editor. :-) Use const effectively to mark your class methods and finally be able to pass constant objects and structures around your code, minimizing the risk of incorrect usage.
  • QML. This would deserve a chapter on its own, but since there has been quite a lot of buzz around it on the internet I won't spend many words on describing it. Instead, I'll focus on how I came to like it so much. As it often happens with new things, my first impression was not so great; sure, all the QML demos you can find in the internet are extremely captivating, and it's impressive how much you can achieve with very little code — which doesn't even look like real code, but more like a static description. And this was indeed my first doubt: what is the limit of QML? It's a nice language for moving graphics items around, but does it let me do anything more than that? Or: if it really allows me to write complex UIs for big applications, won't the code become a horrible mess to maintain? Again, time and hands-on experience is what changed my mind. I'm porting one map application from Gtk+/Clutter to Qt and of course the map widget and its animations has been my first item in the list. Clutter is a fantastic toolkit for producing animated UIs in the GNOME world; the Qt equivalent is QGraphicsView, whose APIs luckily match very close the Clutter ones; so, the porting wasn't that difficult at all, and it didn't took long until I had my widget working. However, for implementing the animations (zoom, panning and rotation of the map) I didn't use the Qt Animation Framework, which would be the natural equivalent to Clutter animation classes, but instead went for QML: exposing the map properties to QML enables implementing animations in a much easier and enjoyable way. QML property bindings, together with property animation descriptions, empower your application to any kind of smooth animations with almost no effort on your side. You don't have to take care of starting/stopping animations, changing the direction of animations while they are running, or combining zooming/panning/rotation at overlapping moments: no matter how crazily the user plays with your UI, all animations happen as expected, without any need for you to special code them. I couldn't help falling in love with QML. :-)
    So, my answers to the above questions are that, first of all, QML is a language especially designed for developing UIs and UI logics. There's not much else that you can do beside that; in order to write algorithms and implement the rest of application (all what is non-UI) you have to resort to either Javascript or C++ (or Python, etc.); the only difference on how you use these languages is that it's possible to write the Javascript code in the .qml file itself, which is very convenient but also, in my humble opinion, something that you shouldn't do. So, while you could say that it is possible to write an entire application in QML, I heartily discourage you from doing so; if you really like Javascript (why would you, by the way?) and want to write your application with it and QML, it's much better to write the code of your application logic in a .js file and import that from QML. About QML code becoming a maze when writing complex applications, I disagree; of course, it's possible, but it's the same in all other languages (which I know of). If you split your code into smaller QML files (per UI component or groups of components) and avoid creating cross dependencies between components, everything will go smoothly — my golden rule when writing QML code is that a .qml file should never refer to identifiers which are not defined in the file itself. The reason why I'm getting so down in technicalities here is that, if you are a developer who has some experience with QML but finds it messy, you should go and check your code against this rule. :-) Indeed, QML is not a panacea which let everyone who is not a developer write über-complex applications; it's easier and more effective than all other languages (which I know of, again), but the rules of good software development still apply.

How you can start liking Qt

No way you will. ;-) Joke aside, there is some truth in that answer: first of all, you will never like Qt until you try it; and you won't try it unless you are forced to, or have some very good reasons to start looking into it. In my case, in fact, I was forced to, and — at that time — I had absolutely no reason to try Qt on my own: I already had some bad memories with it, I didn't like KDE, the skype Linux client and, most importantly, I was totally happy and satisfied with coding C and GObject.

However, I believe that nowadays there might be two reasons why even a hardcore GNOME developer could, in an unforgivable moment of weakness, decide to try programming with Qt: QML and application portability. QML is the new cool stuff (it was not there when I started with Qt), there are plenty of nice demos and examples out there, and they do pretty amazing things. Especially given that setting up the environment is an easy task (just install the Qt packages from your Linux distribution) and running the demos is in most cases just a matter of typing qmlviewer <file>.qml, and that you are a very curious geek, it's not so unlikely that you'll want to have a closer look to the demos; and since the source code consists in most cases of just a few lines of JSON-like text, it won't take long for you to understand it and maybe start playing with it. Especially because I still believe that GNOME developers deserve something as cool as QML. :-)
The other reason why trying Qt nowadays is not so absurd as it might seem is portability. Yes, Qt has always made portability his flag, but who does really care about Windows and Mac? However, what you might care about is Android! What has changed here in the last couple of years is that Qt and QML run on Android, with GL acceleration and multitouch support, enabling you to develop modern applications which can be run on millions of devices; you can also target the best smartphone ever, Symbian smartphones and whatever devices Nokia will come up with for the next billion.

I don't think there is much more I can write to stimulate you to try out Qt or, if you have already started using it, to support your efforts to master it. What I can tell you, with no fear of being contradicted, is that eventually you will like it; there is no way that this won't happen, if you continue learning it. At some point you will realize that going back to C (or even Vala) and GObject is not going to make your programming more productive, or even more enjoyable than how it has become with Qt. It's just a matter of enduring the difficulties and unpleasantness for a long enough time; which can be even several full months if you are, like me, one who takes technologies, programming languages and libraries next to your heart.

One of the new features of the upcoming Nokia N9 is the unified accounts UI and the Single Sign On (SSO) framework. The developer website hosts a page describing this feature in high level terms — a highly recommended reading — and offers a picture of the account creation flow (the orange circle representing the finger tapping is a bit off target in the pictures, bummer):

The UX designers of the N9 decided to create a centralized place where all the user’s accounts would be managed: all the account providers will be listed in this application, and once the user chooses the provider and enters his credentials (only once), he’ll be prompted to select which services he intends to use on this account, in case the provider account gives access to more than one. Once this is done, all the applications interested in the selected services which have been enabled for the new account will start using it.

This design removes the need to implement account management in every application, because all the accounts and their settings are handled in the accounts UI application. Of course, applications can invoke the accounts UI when an account needs to be created, and they can directly embed the account configuration plugin when a specific account needs to be edited.
The accounts UI provides most of its functionality through account plugins. There are provider plugins, whose task is to create the account and handle those settings that are shared through all the account’s services (such as a global option to enable or disable the account), and service plugins, which add support for a specific service within the account and provide a configuration for its settings (at the very least, a toggle switch to enable or disable the service). This plugin based way of operate on accounts brings the possibility to extend the support for new online services, with plugins possibly coming from different sources, from the OS platform vendor to a user’s community, as well as from a hardware vendor, third party software companies and application stores. And all the new services can be directly accessible from the same applications the user is already familiar with, instead of requiring the installation of one additional stand-alone application.

On the other hand, the Single Sign On framework is mostly transparent to the user (indeed, that’s the goal of any SSO implementation): once the password for one service has been entered, all applications operating on the same account should be able to login without bothering the user with password dialogs. And if the password turns out to be wrong, the SSO framework will ask for it only once, no matter how many applications are using the account.
Security is also tightly bound to the MeeGo SSO implementation: at account creation time it’s possible to specify which applications are allowed to use a certain account (or, more technically, which resource tokens an application must possess in order to be granted access to a certain account’s credentials), and what authentication methods are allowed. For instance, for security reasons we might not want to allow an account to be used with any authentication method where the password is disclosed in plain text to the applications or sent over the network.
Last but not least, the account passwords are stored on the device in encrypted form, and the encrypted storage can be dynamically activated/deactivated by providing/removing a master key, which could be configured to be the user password, or a fingerprint or other biometric checksum, some hardware key (such as a SIM card), or pretty much anything else. When the encrypted password storage is unavailable and some applications need to login to a service, the user will be prompted for the needed service password (again not more than once per account); all this being totally transparent to the application.

Using the framework in other devices/platforms

The UI design for the Accounts & SSO components described above is just one of the possible ways of integrating the MeeGo Accounts & SSO framework into a user device. The framework itself has been written to be flexible and support any UI workflow we could think of, without compromises to performance or security. The deployment of the Accounts & SSO framework in other devices and platforms has also been taken into consideration during the architecture and implementation development and several actions were taken towards this goal.

The core software driving the Accounts & SSO frameworks is all open source (LGPL), and can be found in gitorious.org. The most interesting components are:

  • libaccounts-glib: Glib-based API for account management. Depends on SQLite and D-Bus.
  • libaccounts-qt: Qt API for account management. Thin wrapper of libaccounts-glib APIs.
  • signon: the SSO daemon (written with Qt), which provides a D-Bus API. In the same source tree there’s also the libsignon-qt library, for Qt-based clients.
  • libsignon-glib: Glib-based client API for SSO.

Most of the other repositories in the project are probably not very useful outside of MeeGo, and they are not that interesting anyway. What might be more interesting to know, is the list of components that are missing from the gitorious project (because they are not open source), and that another platform/vendor would have to reimplement in order to provide all the functionalities described above. Luckily, there’s not much in this list. Apart from a couple of SSO authentication plugins for specific services, the rest is all about UI parts (because of Nokia’s general policy of not releasing the source code of its UI applications): we don’t have the account application and the account plugins, and the SSO UI daemon serving the password dialogs. This is not a big loss because in the UI would have had to be rewritten anyways to run in other platforms (and for MeeGo as well, as the MeeGoTouch UI library which is used in these Nokia UIs has been deprecated).

Having spent quite a considerable amount of (pleasant) time and energy on this project, I feel rather bound to it even though my employment in Nokia has ended. Therefore, I’m willing to continue to dedicate some of my free time (which, I have to say, is not much) to contribute to it and help its deployment in MeeGo and other Linux based platforms. Don’t hesitate to contact me if you are interested in getting the Accounts & SSO powering the OS you love and would like to know more about it.

Latest news, sport results, stock market quotes, currency conversions, web comics, picture of the day... The internet is filled with dynamic content that you might want to bring into your phone homescreen, but often you don't have a widget that supports the site you are interested in. But now, cry no more! Oculo is a homescreen widget for the Nokia N900 which can take any web site and render its contents into your homescreen. Not only it can render a complete web-page, you can also choose which specific parts of a web page you are interested in!


The mandatory screenshot. Three instances of Oculo: Flickr! explore, Google local news, Yahoo! finance.

As I'm writing this, Oculo 0.7 is in the Maemo extras-testing repository; I'm using it without problems in my N900, but it's still rather buggy, so if you try and find some problems, don't hesitate to report them. Unfortunately, it is already known that Oculo will not be visible if you are running the community SSU; this is apparently a problem with the CSSU and Qt home widgets which I'm investigating. Also, since the configuration procedure might not be as intuitive as it could be, I've created a video which shows how to configure it:

History and technical aspects

The idea of developing Oculo (which means “eye” in interlingua) came to me a few months ago, when I noticed that Radek, a colleague of mine, was checking the daily menu of our canteen in the intranet pages. I ironically suggested him that he should write a maemo home widget showing the daily menu, so he could have it always visible on his phone. The fact that I considered “silly” the idea of writing a homescreen widget just for that goal suddenly brought up the idea of Oculo: giving the user the possibility to put in his homescreen whatever web content he desires.

Using Qt and QWebKit to render the web page contents into an image was unbelievably simple, and boosted my motivation in developing the widget. In a couple of days I already got something that was usable to me; but as Mappero users know, my usability standards are quite low :-), and this time I realized that I couldn't just publish Oculo in that state. So I went on developing the configuration dialog, tried hard to improve the graphical appearance of the widget (which still looks bad, but you haven't seen how it was before :-p) and solve some performance issues. The biggest of which was the memory consumption of the widget due to keeping QWebKit loaded in memory; this has now been solved by moving the configuration phase and the web content retrieval/rendering into a separate process, which is running only when needed. The homescreen widget itself is just a container for the image.

Future developments

A quick roadmap of what should be coming for Oculo:

  • Minimum interval between updates will be configurable (this is trivial and will be coming very soon)
  • Speed improvements: try not to load external content which will not be rendered
  • Share configurations between users; let users upload/download their configuration to a central server — this will make the configuration much easier
  • Port Oculo to MeeGo (to be investigated)
  • Port Oculo to Linux desktops
  • If Qt on Android can be used to develop home screen widget, an Android port might also be possible.

That's all for now! Go and try Oculo out, and let me know your impressions. :-)

Hello everyone! As some of you know, I've developed a photo manager application for Ubuntu phones, called Imaginario (which in interlingua means something like "collection of images").
Imaginario on the Ubuntu phone
Last February Imaginario has reached feature completion, meaning that I'm quite satisfied with the features it offers (but if you find it lacking, then by all means please let me know by filing a bug report). I recently bought an Ubuntu tablet, the BQ M10, and verified that Imaginario works fine in the tablet form factor, even though it could be improved to use the adaptive page layout widget in a few places.

Anyway, the relative quietness the project had reached was starting to scare me, therefore since March I've been working on a desktop version of Imaginario, which shares the same code base but renders its interface via the QtQuick Controls module, which provides native-looking widgets on Linux, OS X and Windows. The goal is indeed to create a cross-platform photo manager, heavily inspired by the fantastic F-Spot which has been hibernating for the last 6 years but which I'm still happily using.
Imaginario is under development for your desktop!
I'm in no way done. I've got the application in a stage where I can start playing with it and some basic functionality is working, but I'm not yet ready to entrust it with my photo collection ­— though indeed, so far I haven't experienced any data loss or data damage.
That's why I think this is a good time to share the news, in the hope that I could find someone else (besides me) who could test the software and report bugs.

What should work:

  • Import your photo database from F-Spot
  • Import your photo database from Shotwell
  • Import photos from a folder
  • Edit photo tags
  • Search by tag (with OR/AND operators exactly like F-Spot does)
  • Search by geolocation

What does not (yet) work

  • More search filters (by date, rating)
  • Hidden tags
  • Exporting (but you can select photos and copy their URI to the clipboard)
  • Translations of UI elements
  • UI needs love
In the process of developing Imaginario with the QtQuick Controls I've also had to occasionally report (and fix, or workaround) some bugs on the controls themselves, which will hopefully come as a benefit for other applications using them.

How to install and test it

If you have been reading till this point, there's a little chance that you might actually be interested in helping me out with testing this app. I don't have any builds for OS X or Windows yet, but there are automatic daily builds for Ubuntu 14.04 (trusty) and 16.04 (xenial), available in my imaginario PPA. To install imaginario, just run these commands:
sudo add-apt-repository ppa:mardy/imaginario
sudo apt-get install imaginario
If you are interested in building it for other OSes, you can find the source code here, but please don't distribute any binary packages yet, as the software is all but ready to be used in the wild.

Closing note on QtQuick Controls vs Ubuntu UI toolkit

Those of you who are familiar with the Ubuntu phone might wonder why I've decided to use the QtQuick Controls and not the Ubuntu UI toolkit like I'm doing with the phone version. After all, the Ubuntu UI toolkit has been specifically planned to support the desktop use case too, and it would be just natural to take its convergence feature into use and let it handle the desktop version too.
There are a couple of reasons why I haven't been following this path:

  1. I want the app to be working in Windows and OS X too
  2. I want traditional desktop elements, such as split views, treeviews and menus
There is a good chance that — despite its name — the Ubuntu UI toolkit would work just fine under Windows and OS X, but it's clearly not a requirement, and the possibility that the compatibility gets broken is very real. Besides, in any case that wouldn't offer me a native-looking UI; not that I consider this to be  priority, but it's certainly a bonus point for the QtQuick Controls.
As for the other point, it's likely that split views, treeviews and menus are coming to the Ubuntu UI toolkit too, but of course I'm developing Imaginario now, and I have to use what is available at this very moment.
All in all, none of the above is a strong reason to chose one toolkit over the other; and it's actually not unlikely at all that in the future I'll decide to go for the Ubuntu UI toolkit on all OSes and all form factors; I've just made a contingent choice, which suits me fine for now but which I'm open to revisit anytime.

If anything, this double face of Imaginario shows the strength of Qt and QML: the same core C++ classes get exposed as two totally different user interfaces, and the speed of prototyping in QML makes this effort very cheap — I'm not afraid of literally throwing away one user interface or starting a new one from scratch.

    As a Nokia employee working on MeeGo, I feel that my career is going to be deeply affected by the recently announced Nokia strategy. I'm not going to comment on the value of the business decisions; of course I have my opinions about that too, but what I feel more important now is the future of MeeGo, and Linux-based platforms in general, inside Nokia.
    The announcement mentions MeeGo only marginally, as a “longer-term market exploration”, and ends the paragraph with “Nokia still plans to ship a MeeGo-related product later this year”. This sounds to me like: we won't market any MeeGo devices in parallel with Windows Phone ones, not to hinder the latter's success, but we'll release the MeeGo product we're currently working on before downscaling MeeGo back into the R&D division.

    No matter how wrong my interpretation might be, let's try to collect a few facts:

    • MeeGo is ready, it's not an R&D project: a MeeGo phone will be released
    • Nokia's primary platform for the middle/long term is Windows Mobile
    • Meego will become, within Nokia, an R&D project at best

    I feel confused and fooled. Business logics are floating several metres above my head, and I cannot understand what's the point of saying that MeeGo will be an R&D project when it's not. To me, it's like taking a teenager and trying to squeeze him into a baby's cradle. Either you kill him more or less explicitly, or you take him out, let him grow and give him a chance to be a hero. We are going to have the best phone in the market this year. It might not be perfect, as the N900 clearly wasn't, but all the premises for a brilliant future are there. And people will love it, as they loved the N900 despite it being far away from the quality standards we aspired to achieve and despite a zero-digits investment on marketing. Maemo won, against all odds.

    One thing is clear: Nokia is not committed to Linux and the platform for the future Nokia devices is not going to be Linux-based, at least in the middle term. Because if it were, I can't see a reason why it couldn't be MeeGo.

    If I try to imagine my future career in Nokia, I see myself either working on applications or R&D projects on top of Windows Mobile, or trying to squeeze the teenager into the cradle, and maybe put him into the refrigerator and periodically check that he doesn't die, because hey, he's our far future hope.
    So, what do I have against Windows Mobile? Simple: it's closed source software. And it doesn't matter if the software I develop is open-source; on the contrary, if I had to choose between developing open-source software on top of a closed platform and developing closed-source software on top of an open-source platform, I'd much rather go for the second option: because with the first one I'd still be using and promoting a closed platform, and unless you are developing a cross-platform application or framework, you'd be doing very little good to the open source world.

    Summing up. I really wish that Nokia took one step back and revised their plan. Not because I ask it of course, but because the loyal customers, the developers and the investors are asking it. And give a clear statement on what is the future of MeeGo, Linux and open-source within Nokia. Meanwhile, my CV has been updated and has appeared on this blog's navigation menu for anyone to read. Companies committed to Linux are welcome to contact me for proposing a job or even a shorter term collaboration. It would be wonderful if I was given a chance to continue working on MeeGo, work on some cool ideas, work to introduce the Accounts & SingleSignOn framework to more Linux distributions and open-source OSes. Or actually, anything where I would be given a chance to develop on top of open-source software.
    Proposals from Nokia are welcome as well.

    Note: in this blog post I'm talking only about MeeGo because it's what's affecting me most, and I wanted to keep the post to the point. It doesn't mean that I don't care about Symbian's future and Qt deployment.

    December 02, 2018

    This week in Usability & Productivity we did a lot of work on our Plasma 5.12 long-term support release and performance improvements for KIO and Baloo (many of which are not individually significant enough to be mentioned here, but will add up to some great improvements over time). Lots of nice bugfixes and new features snuck in, too.

    New Features

    Bugfixes & Performance Improvements

    User Interface Improvements

    Next week, your name could be in this list! Not sure how? Just ask! I’ve helped mentor a number of new contributors recently and I’d love to help you, too! You can also check out https://community.kde.org/Get_Involved, and find out how you can help be a part of something that really matters. You don’t have to already be a programmer. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

    If my efforts to perform, guide, and document this work seem useful and you’d like to see more of them, then consider becoming a patron on Patreon, LiberaPay, or PayPal. Also consider making a donation to the KDE e.V. foundation.

    December 01, 2018

    December just started, and this year I want to try to do something a bit similar to advent calendars: make a new release of one of my (too) many projects every weekend! This release month begins with the release of Doxyqml 0.5.0, an input filter to let you document your QML code using Doxygen.

    Just like in version 0.4.0, most of the work has been done by other contributors, with me taking care of reviewing the code and improving project infrastructure (improving tests, adding coding style checks...). Here is the list of changes:

    • Turn internal QML elements into private C++ members, see README.md for details on how to use this. (Matthew Lam)
    • Add support for @returns, a synonym for @return. (Max Paperno)
    • Add support for trailing (inline) Doxygen comments for properties, signals, and methods (but not method parameters). (Max Paperno)
    • Fix installation issues on Windows (Max Paperno)
    • Improve test coverage and infrastructure (Aurélien Gâteau)
    • Setup flake8 to enforce coding style (Aurélien Gâteau)

    As usual, you can get it using pip:

    pip3 install --upgrade doxyqml

    Or download the source code.

    That's it for this release, see you next weekend for a new release of another project...

    It’s already two month since I last wrote a summary on recent developments in KDE Itinerary, so here is what happened in October and November. With the 18.12 application release coming up shortly, that’s also largely what you can expect in there.

    New Features

    The probably biggest visible change is the introduction of automatic trip grouping. That is, multiple elements (flights, train reservations, hotel bookings, etc) belonging to the same trip are grouped together in the timeline and can be collapsed for a better overview.

    This might sound simple (and for a human it is), but finding a reliable way to automatically group things, and to automatically name the resulting trip, is actually quite tricky. Some of the challenges include:

    • Trips that don’t return to the starting point. It’s not uncommon for larger urban areas to have multiple airports that all are viable “home airports”. E.g. TXL -> CDG -> SXF should be detected as a trip group, despite technically not being a loop. A distance threshold addresses this to some extend, but would need to be fairly large to also work e.g. for all of London’s airports.
    • Distinguishing between changeover stops and the actual destinations. This matters for picking good default names for trips. We use hotel bookings as an indication for this, the length of a stay between two location changes might also be interesting to look at. Assuming a trip is symmetric however isn’t working.
    • Incomplete data. This can be just not yet imported or booked elements of a trip, or elements that simply don’t exist. The Randa demo data set shows this for example with the unidirectional bus trip from Randa to Zermatt, which is followed by a (missing) hike back. A strict connectivity search would detect that gap and wrongly interrupt the trip there. By also looking for the matching reservation numbers of the enclosing flights we can still make this work.
    • Missing city names. This is again mostly a problem for naming, as cities are often the best level of detail for describing the destination. That is “Munich” makes sense while “Franz Joseph Strauss” (fallback to airport name) or “Germany” (fallback to country name) are sub-optimal, the latter particularly if we started in that country.

    As you can imagine this needs a lot of fine tuning to produce useful results, and possibly additional search and naming strategies for cases not yet considered. So this is a good place to help, if you have particularly complex trips or other cases where the current approach could produce better results, or just ideas on how to improve this, please let us know.

    That’s not all that is new though, Nicolas started to work on adjusting the screen brightness when getting ticket barcodes scanned on your phone. So far we have Linux/Solid support for Plasma Mobile, Android support is still to come. This makes it less likely that you are the unpopular person to stall the boarding queue ;-)

    Infrastructure Work

    • Post-processing of extracted data can now employ libphonenumber. Given a partial address e.g. of a hotel or a restaurant, this allows us to determine the country from an international phone number, or the other way around make a local phone number internationally dial-able when we know the country. There is more that libphonenumber can do, such as determining the city or timezone from a given number, that still has to be integrated though.
    • Custom extractors can now also specify filter expressions on proprietary barcode content. This allows us for example to select the SNCF ticket extractor without having the email context for such a PDF document. So far this was only possible on standard barcodes like IATA BCBP or UIC 918.3.
    • A new convenience method for extractor scripts allows to turn the often found Google Maps URLs into JSON-LD geo coordinate objects.

    Important Fixes

    • We switched to a newer variant of the ZXing barcode decoding library. This fixes a few cases of failed detection of PDF417 codes with small module sizes (common in boarding pass PDF files), and as a very welcome side-effect increases performance and fixes a memory leak on failed barcode detections.
    • The airport identification code now considers a few more alternative transliterations of non-ASCII characters. This allows us to properly identify more airports from their (translated) human-readable names and look up information from the Wikidata knowledge database about them.
    • Nicolas implemented generic airline name extraction from Apple Wallet boarding passes.
    • Weather forecast in KDE Itinerary now also works for negative coordinates.

    Performance Improvements

    • The schema.org based value classes got a shared null state optimization, and avoid detaching their internal state when their property setters are called with unchanged values (see separate post on this). This saves a significant amount of memory allocations during post-processing of extracted data.
    • We reduced the need for expensive image scaling operations in barcode extraction from PDF files and improved the heuristics on which graphics found in a PDF could even be a valid barcode, which combined with the better ZXing variant mentioned above cuts the runtime of the extractor test suite by almost half. PDF extraction performance is important as the KMail plug-in applies this much more aggressively then in the previous release.

    UI Improvements

    • Importing and pasting content into KDE Itinerary got streamlined by supporting remote URLs too, and by auto-detecting content. So there’s only a single workflow for all supported content types now.
    • The timeline model got a vastly improved test system, which enabled us to fix a number of merge fails when importing data, resulting in duplicated or otherwise wrong elements in the timeline.

    Contribute

    Again a big thanks to everyone who donated test data, this helps immensely, please keep it coming!

    If you want to help in other ways too, see our Phabricator workboard for what’s on the todo list, for coordinating work and for collecting ideas. For questions and suggestions, please feel free to join us on the KDE PIM mailing list or in the #kontact channel on Freenode.

    November 30, 2018

    During the development cycle of 5.12 we’ve been working on making it easier to use Qt Lite in Yocto builds, especially those using our meta-boot2qt layer.

    Qt Configuration Tool now has the ability to export the set of selected Qt Lite features into files that can be used by the Yocto build to build a slimmer Qt.

    Qt Configuration Tool is commercial-only and allows you visually explore and toggle different optional parts of Qt after opening an initially configured source tree. It can be used directly to configure that source tree for builds that don’t include features that you don’t need. That configuration can also be exported into a single file that can imported later, which makes sharing the configuration between people easier.

    Previously there however wasn’t a clear path to using that in a Yocto-driven build, since meta-qt5 recipes build Qt module by module. New version 1.2 of the tool and the new qt5-features class in meta-boot2qt layer provide that. Both are available in Qt for Device Creation 5.12.

    1. Run ./configure for a qt5 source tree with the necessary options for your
      platform and choosing the commercial license.
    2. Open Qt Configuration Tool and select the build directory from the previous step.
    3. Select/unselect the features you want with the tool.
    4. When the configuration is ready, select “File” > “Export Features for
      Boot2Qt” and pick a folder. A feature file for each module that you’ve made
      changes to is created into that folder.
    5. In your yocto build, for each module that you have a feature file for:
      1. Create a new recipe extension for the module, e.g. “qtdeclarative_git.bbappend”.
      2. Add the line “inherit qt5-features” into that bbappend file.
      3. Put the feature file for the module (e.g. “qtdeclarative.opt”) into a
        features/ directory next to your bbappend file.

    Then run your build (bitbake b2qt-embedded-qt5-image if you are basing your build on our example images) and enjoy the slimmer Qt made just for you!

    The post How to use Qt Lite with Yocto appeared first on Qt Blog.

    So far, so good! We're having quite a variety of students and I'm happy to see new ones still joining. And surprising to me, we're still getting beginner tasks being done, which keep us busy.

    New this round were some tutorials written by Pranam Lashkari. I hope we can expand on this next year, because I think a lot of students who are willing to do these tutorials one by one are learning a lot. His thought is that they can be added to our documentation after the contest is over. I think we can re-use some stuff that we've already written, for next year. What do you think?

    In addition, I'm seeing loads of work -- yes, small jobs, but keep in mind these kids are 13 to 18 years old* - for the teams who were willing to write up tasks and tutor. It is a lot of work so I really appreciate all those mentors who have stepped forward.

    I'm very glad we are participating this year. It isn't as wild and crazy as it was in the beginning, because there are now lots more orgs involved, so the kids have lots of options. Happy that the kids we have are choosing us!

    -----------------

    * Rules state: "13 to 17 years old and enrolled in a pre-university educational program" before enrolling. https://developers.google.com/open-source/gci/faq

    On the 2nd of December, the Kdenlive team will be holding an open bug-squashing day in preparation for the major refactoring release due in April 2019. Everybody is invited!

    This is a great opportunity for developers of all levels to participate in the project. The team has triaged hundreds of reports, closing more than a hundred of them in the past month. Kdenlive developers have also made a list of entry-level bugs you can get started with.

    For the more seasoned developers, there are plenty of options - be it a shiny feature request or a challenge to polish some non-trivial edges. To hack Kdenlive, you need to know C++, Qt, QML or KDE Frameworks. Those with knowledge of C can join the fun by improving MLT, the multimedia framework Kdenlive runs on.

    Even if you have no programming experience, you can still help by testing fixes and features, as well as by triaging more bug reports.

    Check out the list of proposed bugs to solve in our workboard under the "low hanging / junior jobs" section.

    Bug-squash Schedule

    10h-10h30 CET: introduction of the event, presenting goals and tools, test the latest refactoring AppImage, how to help the project

    10h30-12h CET: Introduce yourself, get help in your development setup, choose your bug and work on it with help from the team

    12h -13h CET: Lunch break

    13h - 17h CET: Bug fixing - continue morning tasks or introduce yourself if you just joined, get help in your development setup, choose your bug and get help if you need it

    16h - 17h CET: Brainstorm: Timeline colors

    17h - 18h CET: Closing thoughts, evaluation, general issues, future planning

    Spread the word and join us! All the information on how to join is here.


    Older blog entries


    Planet KDE is made from the blogs of KDE's contributors. The opinions it contains are those of the contributor. This site is powered by Rawdog and Rawdog RSS. Feed readers can read Planet KDE with RSS, FOAF or OPML.