Sitting on Lake Zurich and reflecting over things was a great way to get started. http://manifesta.org/2015/11/pavillon-of-reflections-for-zurich-in-2016/
After spending a bit of time in a train, I climbed part of a mountain together with Adriaan – up to the snow where I could throw a snowball at him. We also designed a couple of new frameworks on our climbing trip. Maybe they will be presented later.
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:
|
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)
|
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)
|
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)
|
1 2 |
2 : error: use of undeclared identifier ‘x’ template <typename T> auto foo(const T& t) -> decltype(x.first) |
ICC (13)
|
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.
So. KDE has landed at Qt World Summit.
You can come and visit our booth and …
KDE – 19 years of Qt Experience.
Unfortunately, with all the normal magic of QML property bindings, getting a property updated in a setup that involves return values from functions isn’t really doable, like this:
|
1 2 3 |
Text { text: qtobject.calculatedValue() } |
I’m told there is a low priority feature request for a way of signalling that a function now returns a different value and all properties using it should be reevaluated.
I have so far discovered two different workarounds for that that I will be presenting here.
Using an extra property
Appending an extra property to trigger the reevaluation of the function is one way of doing it.
|
1 2 3 |
Text { text: qtobject.calculatedValue() + qtobject.emptyNotifierThing } |
with the following on the C++ side:
|
1 2 3 4 |
Q_PROPERTY(QString emptyNotifierThing READ emptyString NOTIFY valueChanged) QString emptyString() const { return QString(); } |
This is a bit more code to write and to remember to use, but it does get the job done.
Intermediate layer
Another way is to inject an intermediate layer, an extra object, that has the function. It can even be simplified by having a pointer to itself.
|
1 2 3 |
Text { text: qtobject.dataAccess.calculatedValue() } |
with the following on the C++ side:
|
1 2 3 4 |
Q_PROPERTY(QObject* dataAccess READ dataAccess NOTIFY valueChanged) QObject* dataAccess() { return this; } |
It seems a bit simpler for the reader on the QML side, but also gets the job done.
I am not sure which way is the best one, but the intermediate layer has a nicer feeling to it when more complicated types are involved.
For reasons I don’t know, apparantly a Qt Quick Item that can show a QImage or a QPixmap is kind of missing. The current Image QML item only works with data that can be represented by a URL.
So I wrote one that kind of works. Comments most welcome.
It is found on git.kde.org: http://quickgit.kde.org/?p=scratch/sune/imageitem.git
Oh, and the KDE End of Year fundraiser is still running. https://www.kde.org/fundraisers/yearend2014/. Go support it if you haven’t already.
Occasionally, various quotes from people having an opinion if linux is about choice or not. Even pages like http://www.islinuxaboutchoice.com/ has shown up.
My short answer is “YES”. Linux is about choice. And you get all your choices directly from your f/loss definition of choice (FSF’s 4 freedoms / OSI’s opensource definition / Debian Free Software Guidelines)
It doesn’t mean that you get all the gui configuration bits that you want. It doesn’t mean that you without any problems can switch out any component. But it does mean that you can get it exactly your way. But it might require you to edit some source code and compile some stuff.
Recently I was trying some statistics on the qtbase-module (where QtCore, QtGui, QtWidgets and so on lives) and was wondering who made them.
Not based on their current paid affilation, like Thiago’s graphs, but if each commit was made by a person coming from KDE.
So, I got hold of Thiago’s scripts, a lovely mix of perl and zsh, and a QtBase git repository. First steps was to try to classify people as person coming from KDE or not. Of course, I’m a KDE person. Thiago is a KDE person. David Faure is a KDE person. Olivier Goffart is a KDE person. Lars Knoll is a KDE person.
By the help of the KDE accounts file, and some of the long time KDE contributors, I got after a half day of work a good list of it. Then next steps was trying to put it into Thiago’s perlscripts
All of it kind of succeeded:
So, KDE people makes up for 40-60% of the weekly commits to QtBase. This is again shows that KDE is important to Qt, just as the reverse is. So, let’s keep KDE healthy.
KDE is running a end-of-year fundraiser over here https://www.kde.org/fundraisers/yearend2014/. Go ahead and donate, and help KDE stay healthy. For your own sake. And for Qt’s.
Occasionally, one gets in touch with kind of ‘foreign’ technologies and needs to get stuff working anyways.
Recently, I had to do some various hacking with and around .bat files. Bat files are a kind of script files for Microsoft Windows.
Calling external commands
Imagine need to call some other command, let’s say git diff. So from a cmd thing, you would write
|
1 |
git diff |
similar to writing shell scripts on unixes. But there is a catch. If the thing you want to call is another bat-script, just calling it ensures it ‘replaces’ the current script and never returns. So you need
|
1 |
call git diff |
if the command you want to run is a bat file and you want to return to your script.
Calling an external helper next to your script
If you for some reason needs to call some external helper placed next to your script, there is a helpful thing to do that as well. Imagine your helper is called helper.bat
|
1 |
call %~dp0helper.bat |
is the very self-explanatory way of doing that.
Stopping execution of your script
If you somehow encounter some condition in your script that requires you to stop your script, there is a command ‘exit’ handy. It even takes a argument for what error code there is.
|
1 |
exit 2 |
stops your script with return code 2. But it also have the nice added feature that if you do it in a script you run by hand in a terminal, it also exits the terminal.
Luckily there is also a fix for that:
|
1 |
exit /b 2 |
and it doesn’t exit your interactive terminal, and it sets the %ERRORLEVEL% variable to the exit code.
Fortunately, the fun doesn’t stop here.
If the script is run non-interactively, exit /b doesn’t set the exit code for for example perl’s system() call. You need to use exit without /b for that. So now you need two scripts. one for “interactive” use that calls exit /b and a similar one using exit for use by other apps/scripts.
Or, we can combine some of our knowledge and add a extra layer of indirection.
|
1 2 |
call %~dp0script.bat exit %ERRORLEVEL% |
and then success.
Oh. and on a unrelated note. Windows can’t schedule tasks for users that aren’t logged in and don’t have a password set. The response “Access Denied” is the only clue given.