qt – Page 2 – Blog :: Sune Vuorela

Where KDEInstallDirs points to

The other day, some user of Extra CMake Modules (A collection of utilities and find modules created by KDE), asked if there was an easy way to query cmake for wherever the KDEInstallDirs points to (KDEInstallDirs is a set of default paths that mostly is good for your system, iirc based upon GNUInstallDirs but with some extensions for various Qt, KDE and XDG common paths, as well as some cross platform additions). I couldn’t find an easy way of doing it without writing a couple of lines of CMake code.

Getting the KDE_INSTALL_(full_)APPDIR with default options is:

$ cmake -DTYPE=APPDIR ..
KDE_INSTALL_FULL_APPDIR:/usr/local/share/applications

1 2	$ cmake -DTYPE=APPDIR .. KDE_INSTALL_FULL_APPDIR:/usr/local/share/applications

and various other options can be set as well.

$ cmake -DCMAKE_INSTALL_PREFIX=/opt/mystuff -DTYPE=BINDIR ..
KDE_INSTALL_FULL_BINDIR: /opt/mystuff/bin

1 2	$ cmake -DCMAKE_INSTALL_PREFIX=/opt/mystuff -DTYPE=BINDIR .. KDE_INSTALL_FULL_BINDIR: /opt/mystuff/bin

This is kind of simple, but let’s just share it with the world:

cmake_minimum_required(VERSION 3.0)
find_package(ECM REQUIRED)
set (CMAKE_MODULE_PATH ${ECM_MODULE_PATH})

include(KDEInstallDirs)

message(“KDE_INSTALL_FULL_${TYPE}: ” ${KDE_INSTALL_FULL_${TYPE}})

1

2

3

4

5

6

7

cmake_minimum_required(VERSION 3.0)

find_package(ECM REQUIRED)

set (CMAKE_MODULE_PATH ${ECM_MODULE_PATH})

include(KDEInstallDirs)

message(“KDE_INSTALL_FULL_${TYPE}: “ ${KDE_INSTALL_FULL_${TYPE}})

I don’t think it is complex enough to claim any sorts of copyrights, but if you insist, you can use it under one of the following licenses: CC0, Public Domain (if that’s in your juristiction), MIT/X11, WTFPL (any version), 3-clause BSD, GPL (any version), LGPL (any version) and .. erm. whatever.

I was trying to get it to work as a cmake -P script, but some of the find_package calls requires working CMakeCache. Comments welcome.

2018-05-20

Modern C++ and Qt – part 2.

I recently did a short tongue-in-cheek blog post about Qt and modern C++. In the comments, people discovered that several compilers effectively can optimize std::make_unique<>().release() to a simple new statement, which was kind of a surprise to me.

I have recently written a new program from scratch (more about that later), and I tried to force myself to use standard library smartpointers much more than what I normally have been doing.

I ended up trying to apply a set of rules for memory handling to my code base to try to see where it could end.

No naked delete‘s
No new statements, unless it was handed directly to a Qt function taking ownership of the pointer. (To avoid sillyness like the previous one)
Raw pointers in the code are observer pointers. We can do this in new code, but in older code it is hard to argue that.

It resulted in code like

    m_document = std::make_unique<QTextDocument>();
    auto layout = std::make_unique<QHBoxLayout>();
    auto textView = std::make_unique<QTextBrowser>();
    textView->setReadOnly(true);
    textView->setDocument(m_document.get());
    layout->addWidget(textView.release());
    setLayout(layout.release());

1

2

3

4

5

6

7

m_document = std::make_unique<QTextDocument>();

auto layout = std::make_unique<QHBoxLayout>();

auto textView = std::make_unique<QTextBrowser>();

textView->setReadOnly(true);

textView->setDocument(m_document.get());

layout->addWidget(textView.release());

setLayout(layout.release());

By it self, it is quite ok to work with, and we get all ownership transfers documented. So maybe we should start code this way.

But there is also a hole in the ownership pass around, but given Qt methods doesn’t throw, it shouldn’t be much of a problem.

More about my new fancy / boring application at a later point.

I still haven’t fully embraced the c++17 thingies. My mental baseline is kind of the compiler in Debian Stable.

2018-05-11

Modern C++ and Qt

layout->addWidget(std::make_unique<QLabel>().release());

1	layout->addWidget(std::make_unique<QLabel>().release());

– ’cause raw new’s are bad.

2018-05-05

Aubergine – Playing with emoji

Playing with emojis

At some point, I needed to copy paste emojis, but couldn’t find a good way to do it. So what does a good hacker do?
Scratch an own itch. As I wrote about in the past, all these projects should be shared with the rest of the world.
So here it is: https://cgit.kde.org/scratch/sune/aubergine.git/

It looks like this with the symbola font for emojis: Screenshot

It basically lets you search for emojis by their description, and by clicking on a emoji, it gets inserted into the clipboard.

As such, I’m not sure the application is really interesting, but there might be two interesting bits in the source code:

A parser for the unicode data text files in /usr/share/unicode/NamesList.txt is placed in lib/parser.{h,cpp}
A class that tries to expose QClipboard as QML objects placed in app/clipboard.{h,cpp}. I’m not yet sure if this is the right approach for that, but it is the one that currently makes most sense in my mind. If I’m receiving proper feedback, I might be able to extend/finish it and submit it to Qt.

And of course, now it is simple to describe fancy cooking:

ðŸ† ðŸ”ª ðŸ”¥
(aubergine) (hocho) (fire)

I â£ emoji

2017-12-30

KDE still makes Qt

A couple of years ago, I made a blog post, KDE makes Qt, with data about which percentage of Qt contributions came from people starting in KDE. Basically, how many Qt contributions are made by people who used KDE as a “gateway” drug into it.

I have now updated the graphs with data until the end of September 2017:

KDE still makes Qt

Many of these changes are made by people not directly as a result of their KDE work, but as a result of their paid work. But this doesn’t change the fact that KDE is an important project for attracting contributors to Qt, and a very good place to find experienced Qt developers.

2017-10-17

Leaky lambdas and self referencing shared pointers

After a bit of a debugging session, I ended up looking at some code in a large project

m_foo = std::make_shared<SomeQObject>();
/* plenty of lines and function boundaries left out */ 
(void)connect(m_foo.get(), &SomeQObject::someSignal, [m_foo]() {
  /* */
});

1

2

3

4

5

m_foo = std::make_shared<SomeQObject>();

/* plenty of lines and function boundaries left out */

(void)connect(m_foo.get(), &SomeQObject::someSignal, [m_foo]() {

/* */

});

The connection gets removed when the pointer inside m_foo gets de-allocated by the shared_ptr.
But the connection target is a lambda that has captured a copy of the shared_ptr…

There is at least a couple of solutions.

Keep the connection object (QMetaObject::Connection) around and call disconnect in your destructor. That way the connection gets removed and the lamda object should get removed
Capture the shared pointer by (const) reference. Capture the shared pointer as a weak pointer. Or as a raw pointer. All of this is safe because whenever the shared pointer gets a refcount of zero, the connection gets taken down with the object.

I guess the lesson learnt is be careful when capturing shared pointers.

2016-07-14

Let Qt models meet std::vector<std::tuple<…>>

The problem

So. I was stuck with a container of tuples that I wanted to see in a Qt view (QTableView, QtQuick ListView or similar). So how to do that?

Another problem: I haven’t been doing fun things with templates recently.

A solution?

After a bit of hacking, it seems like it can just be done like

typedef std::tuple<std::string, QString> Element;
typedef std::vector List;
List list = { std::make_tuple(“first”, “second”), 
              std::make_tuple(“third”, “fourth”) };
std::unique_ptr<TableModel> magic = createTableModel(list);
QTableView view;
view.setModel(magic->model());

1

2

3

4

5

6

7

typedef std::tuple<std::string, QString> Element;

typedef std::vector List;

List list = { std::make_tuple(“first”, “second”),

std::make_tuple(“third”, “fourth”) };

std::unique_ptr<TableModel> magic = createTableModel(list);

QTableView view;

view.setModel(magic->model());

and … tada:

Of course, we are also QtQuick friendly

std::unique_ptr<ListModel>List>> magic = createListModel(list);
// expose magic->model() to your quickview

1 2	std::unique_ptr<ListModel>List>> magic = createListModel(list); // expose magic->model() to your quickview

and a delegate containing the following

Text {
    text: role0
}
Text {
    text: role1
}

1

2

3

4

5

6

Text {

text: role0

}

Text {

text: role1

}

can give:

But enough about creation.

Whattabout manipulation?

Luckily we got you covered. Insert two extra rows at position 1?

auto lines = { std::make_tuple(“extra”, “extra”),
               std::make_tuple(“extra2″,”extra2”) };
magic->insertRows(1,lines.begin(), lines.end());

1

2

3

auto lines = { std::make_tuple(“extra”, “extra”),

std::make_tuple(“extra2”,“extra2”) };

magic->insertRows(1,lines.begin(), lines.end());

Append a row?

magic->appendRow(std::make_tuple(“”,””));

1	magic->appendRow(std::make_tuple(“”,“”));

Remove 2 rows at position 3?




		
		
			
			
C++
			
			magic->removeRow(3,2);
			
				
					
				
					1
				
						magic->removeRow(3,2);

Replace the underlying list?

List newList;
// fill list
magic->reset(newList);

1

2

3

List newList;

// fill list

magic->reset(newList);

Read-only looping over the elements?

for(const Element& e : magic->list())
{
    …
}

1

2

3

4

for(const Element& e : magic->list())

{

...

}

The Qt model of course also accepts setData calls.

Future?

If anyone is interested I will polish the code a bit and publish it. If that’s the case, how should I name this thing?

And I did get around doing fun things with templates again.

2016-07-10

R is for Randa

This week I have been gathered with 38 KDE people in Randa, Switzerland. Randa is a place in a valley in the middle of the Alps close to various peaks like Matterhorn. It has been a week of intense hacking, bugfixing, brainstorming and a bit of enjoying the nature.

R is for Reproducible builds

I spent the first couple of days trying to get the Qt Documentation generation tool to reproducible generate documentation. Some of the fixes were of the usual ‘put data in an randomized datastructure, then iterate over it and create output’, where the fix is similar well known: Sort the datastructure first. Others were a bit more severe bugs that lead to the documentation to shuffle around the ‘obsolete’ bit, and the inheritance chains. Most of these fixes have been reviewed and submitted to the Qt 5.6 branch, one is still pending review, but that hopefully gets fixed soon. Then most of Qt (except things containing copies of (parts) of webkit and derivatives) should be reproducible.

R is for Roaming around in the mountains

Sleeping, hacking and dining in the same building sometimes leads to a enormous desire for fresh air. Luckily in the middle of the alps, it is readily available, and at least once a day many people went for a walk. To say hi to a sheep. Or to just go uphill until tired and then going back down. Or just finding a circle around. For this area, OpenStreetMap seems to have better maps than Google. We also went on a nice group trip to Zermatt and surroundings, sponsored by our friends in Edeltech.

R is for Releasing

One of the tasks I set myself for was to get my barcode generation library (prison. you know. being behind bars.) ready for release. A bit of api cleanup, including some future proofing, was done, and all users adapted. Hopefully it will be released as part of the next KDE Frameworks release.

R is for Reviewing code

When signing up for the sprint, one has to declare a couple of tasks to work on. One of the things I put myself up to was reviewing David Faure’s code changes. First, he is very productive, and second, he often gets into creating patches in code areas where many other contributors are scared to look. So someone has to do it, and code never scared me.

R is for Running

I planned on going running along the river monday, wednesday and friday. Fortunately that happened, but due to Switzerland having a bit more ups and downs than flat Denmark, it didn’t go that fast.

R is for Random bugfixing

When in the hacking mood surrounded by great developers, it is very easy to just fix minor bugs when you encounter them. There is likely someone around who knows the code in question. Or you are just in the mood to actually fix it, rather than living with a missing clock applet or a corner case crash.

R is for Rubber ducking

I am a brilliant person sized rubber duck. And I did get the opportunity to show off my skills a couple of times, as well as using some of the other people for that.

R is for Raising money

These sprints in Randa is only possible because of all the nice donations from people and companies around the world. The fundraiser is still running, and can be found at

Help us keep going, at this and many other sprints, clickety-click! :D

2016-06-18

Compilers and error messages

So. I typo’ed up some template code the other day. And once again I learned the importance of using several c++ compilers.

Here is a very reduced version of my code:

#include <utility>
template <typename T> auto foo(const T& t) -> decltype(x.first)
{
    return t.first;
}
int main()
{
   foo(std::make_pair(1,2));
   return 0;
}

1

2

3

4

5

6

7

8

9

10

#include <utility>

template <typename T> auto foo(const T& t) -> decltype(x.first)

{

return t.first;

}

int main()

{

foo(std::make_pair(1,2));

return 0;

}

And let’s start with the compiler I was testing with first.

MSVC (2013 and 2015)

main.cpp(8): error C2672: ‘foo’: no matching overloaded function found
main.cpp(8): error C2893: Failed to specialize function template ‘unknown-type foo(const T &)’

1 2	main.cpp(8): error C2672: ‘foo’: no matching overloaded function found main.cpp(8): error C2893: Failed to specialize function template ‘unknown-type foo(const T &)’

It is not completely clear from that error message what’s going on, so let’s try some other compilers:

GCC (4.9-5.3)

2 : error: ‘x’ was not declared in this scope
template <typename T> auto foo(const T& t) -> decltype(x.first)

1 2	2 : error: ‘x’ was not declared in this scope template <typename T> auto foo(const T& t) -> decltype(x.first)

That’s pretty clear. More compilers:

Clang (3.3-3.7)

2 : error: use of undeclared identifier ‘x’
template <typename T> auto foo(const T& t) -> decltype(x.first)

1 2	2 : error: use of undeclared identifier ‘x’ template <typename T> auto foo(const T& t) -> decltype(x.first)

ICC (13)

example.cpp(2): error: identifier “x” is undefined
template <typename T> auto foo(const T& t) -> decltype(x.first)

1 2	example.cpp(2): error: identifier “x” is undefined template <typename T> auto foo(const T& t) -> decltype(x.first)

(Yes. I mistyped the variable name used for decltype. Replacing the x with t makes it build).

Thanks to http://gcc.godbolt.org/ and http://webcompiler.cloudapp.net/ for testing with various compilers.

2016-02-02

KDE at Qt World Summit

So. KDE has landed at Qt World Summit.

You can come and visit our booth and …

hear about our amazing Free Qt Addons (KDE Frameworks)
stories about our development tools
meet some of our developers
Talk about KDE in general
Or just say hi!

KDE – 19 years of Qt Experience.

2015-10-05

Category: qt