KDE

KDE Free Qt Foundation Agreement Amended to Cover Qt for Android Port

Published Tuesday December 3rd, 2013 | by

The Qt for Android port is approaching a major milestone. With the final release of Qt 5.2, Android will become a Qt reference (Tier 1) configuration. The work with the Qt for Android port has been actively ongoing for the past year within the Qt Project, and before that, as part of the Necessitas project hosted by KDE. The authors of Necessitas contributed their work to the Qt Project  in the autumn of 2012, which gave a tremendous boost to the development of the port. The dual licensing model of the Qt Project allows both commercial and open-source licensees to benefit from the possibility of running Qt applications on Android devices.

I am very happy to announce that Digia and the KDE Free Qt Foundation have also included the Qt Android port into the KDE Free Qt Foundation Agreement. Via this agreement Android is treated similarly as the KDE Window System. This agreement is the ultimate guarantee that Digia wants to keep both commercial and open-source versions of Qt viable. Although the money to keep Qt R&D ongoing comes from the paid versions of Qt, we believe that the best way to stay ahead and keep Qt as the leading cross-platform application and UI framework is to develop Qt in the open.

I want to once more thank Mr. BogDan Vatra, Mr. Raymond Donnelly, and all the other pioneers who started the Qt for Android port in the Necessitas project, as well as everyone who has contributed to it within the Qt Project. Based on this work, millions of Android users will be able to enjoy the great applications developed with Qt.

Some background and thoughts on this are available in blog post by BogDan.

3 Comments


Posted in Android, KDE

Qt Contributors Summit 2013 – Please register

Published Tuesday May 14th, 2013 | by

Guggenheim mirror balls
Guggenheim mirror balls

Registration for the Qt Contributors Summit 2013 is now open.

Before going into details, I’ve added a photo of the The Guggenheim mirror balls right outside the famous Guggenheim Museum in Bilbao. It can symbolise how every Qt contributor is linked together, working on the same project, using the summit to reflect on how Qt can be developed even better. Ok, Knut, snap out of it. Over to the practicalities.

Qt Contributors Summit 2013 registration is easy. Just use the Qt CS registration form.

Since the Qt Contributors Summit is an invitation-only event, please make sure you fit into one or more of the following before registering:

  • You are a Qt Project maintainer
  • You are a Qt Project approver
  • You took part in the previous Summit (Attendees at Qt CS 2012)
  • You took a sponsorship package including event invitations (coming soon)
  • You are in the organization team.
  • You are invited by a maintainer or the organization team and we still have seats left.
  • KDE Akademy contributor

Please add sessions unconference style

Since the main idea for the Qt CS is to let developers meet and make solutions, now is the time to pre-schedule sessions on the Qt CS program wiki. Please press “Join group” at the top of the wiki-page. We will  give you wiki-access as soon as possible and add you to the group.

13 Comments


Posted in Community, Contributors, KDE

Qt Project Needs Mirrors for the New Download Service

Published Thursday March 28th, 2013 | by

The Qt Project is currently using a content delivery network based solution for distribution of releases. We have been working to improve distribution of Qt open-source packages and now have the setup available for mirroring. Now we need to get more mirrors before going to production.

The idea is to switch to MirrorBrain based system and away from the current content delivery network based service. The work was started a while ago by Daniel Molkentin and now we have the setup available for mirroring. It is very much similar to what KDE is already using, so for many it is quite familiar. At this point I would like to thank Danimo and others from KDE for all the help provided to enable this.

The system is not yet taken into production use, we need to first have enough mirrors in place. Downloads from the new service work, but the system is not yet up to handle the needed load. Currently we have two mirrors in place, and need more before the new download service can be taken into production use.

The new service is for open-source content only. All the commercial Qt licensees are using a separate system. So it is completely ok for non-profit organizations to become a mirror for Qt Project.

If your organization is willing to become a mirror, please follow the steps in the wiki. Or if you know some organization who already provides mirrors, please ask them to become a mirror for the Qt Project.

We are keenly waiting to get the new download service active as it allows much more flexibility than the current setup. Getting the new system into production is also a prerequisite for providing the new online SDK for the Qt Project.

17 Comments


Posted in Announcements, Community, KDE, Open Governance, Releases

Call for Sponsors | 2013 Qt Contributors Summit

Published Wednesday March 13th, 2013 | by

Qt Contributors' Summit. Photo: Alexandra Leisse

This is the 3rd annual Qt Contributors Summit and it will be the biggest summit to date due to our joined forces with the KDE Akademy conference. More than 500 contributors are expected and it’s solely dependent on sponsorship to succeed.

This will foster interaction, knowledge transfer and technical progress in a highly-productive atmosphere where new and veteran contributors can meet to influence the future direction of Qt. The key benefits of sponsoring the joint Qt CS and KDE Akademy conference are:

  • Meeting key Qt and KDE contributors. There will be 500 upstream and downstream developers and key maintainers, making Qt the top-ranked cross platform framework in developer satisfaction[1].
  • Influence how Qt will be developed in the future. Besides the Qt community, there will be many other free software projects and businesses participating in the joint Qt Contributor Summit and KDE Akademy conference.
  • Be visible. A sponsorship gives you valuable promotional possibilities such as visible advertising, prominent talks and international press coverage.

Digia is a confirmed top platinum sponsor of this year’s combined event and we need even more sponsors to make sure that this year’s event is successful.

Sponsorship Options

This year’s event is providing individuals and companies two ways to sponsor – both which come with many valuable promo benefits:

  1. Single sponsorship: Qt Contributors Summit, 15-16 July
  2. Joint event sponsorship: Qt Contributors Summit and KDE Akademy, 13-19 July

For the Qt Contributor Summit, the sponsorship packages range from Small to XL where sponsors are able to showcase their Qt commitment in front of a knowledgeable, enthusiastic and motivated ecosystem via a variety of sponsor benefits solidifying their stance as active contributors and advocates of the Qt technology.

  1. The single Qt CS sponsorship packages and the combined Qt CS and KDE Akademy sponsorship packages in detail

Practical information

Please contact Knut Yrvin at Digia, Qt or Claudia Rauch at KDE, if you would like to receive more information on sponsorship of the Qt Contributors Summit and/or the KDE Akademy conference. Please contact us by this e-mail form.

1. The report: Cross Platform Tools 2012 by VisionMobile surveying 2,400 developers.

Comments Off


Posted in Community, Contributors, Customers, growth, KDE, Open Governance

Qt Contributors’ Summit Joins Forces with KDE Akademy – July 2013

Published Thursday February 14th, 2013 | by

Just after Digia acquired Qt from Nokia, the KDE community suggested to run the Qt Contributors’ Summit together (Qt CS) with the KDE Akademy conference in Bilbao July 15-16 this summer. The conference will be at the Engineering School of Euskal Herriko Unibertsitatea (EHU; The University of the Basque Country) in Bilbao.

Picture Wall from Qt Contrubutors Day in San Francisco

Lars Knoll, the Qt Chief Maintainer & Digia, Qt  CTO says: “I’m really pleased that we can co-organize Qt Contributors’ Summit with the annual KDE Akademy conference this year in Bilbao, Spain. By close co-operation we are combining community and professionals forces to make both Qt and KDE even better”

More than 500 upstream and downstream developers will participate in this combined event which starts July 13 for both KDE and Qt contributors, and ends July 19. This includes key maintainers of both Qt and KDE projects, and top contributors. It will cover many areas of computing, ranging from core library functionality in Qt and KDE to popular user applications used by hundreds of millions of users, integrated with cloud services. All this in a highly productive atmosphere where we combine forces, exchange knowledge, and meet new contributors.

By co-hosting, KDE and the Qt Project will increase their existing Open Governance collaboration even further. Holding their annual conferences at the same time and the same place will foster interaction, knowledge transfer and technical progress. This in Bilbao, which is the beautiful capital of the province of Biscay in the Basque Country, Spain. The Engineering School and the Bilbao city are putting their forces together helping us in the community to be a great conference and contributors summit in 2013.

The entire budget of this event is funded by sponsors. Even if many are doing a lot of voluntary work, sponsrship are what makes Qt CS and the KDE conference happen. There will be sponsorship packages of all sizes. Info and update on this will be provided soon.

You’ll be invited to this conference by a Qt contributor where also registration details will be provided. Registration of session(s) and other practicalities regarding the Qt CS 2013, is found at the Qt Project Web wiki: Qt Contributors’ Summit 2013. Please don’t hesitate to contact us on the email-list: marketing (at) qt-project.org

Comments Off


Posted in Announcements, Contributors, KDE, Open Governance, Qt

Desktop Components for Qt 5

Published Wednesday June 6th, 2012 | by

According to this recent poll, Desktop Components is one of the most desired add-ons for Qt Quick 2. To help make this a reality we have moved the Desktop Components project over to codereview.qt-project.org and are now accepting contributions, for both the Qt Quick 1 & 2 versions. Several good contributions have been made already, and at the same time a few of us here at Nokia have been working on bringing the components up to speed on Qt 5.

The components are hosted as a Qt Playground project and won’t be a part of the 5.0 release. They will instead have separate releases, most likely in sync with the Qt 5 releases. At some point we will look at making them a proper part of Qt 5.

Project details are available at the wiki. Here’s a quick getting started script:

git clone https://git.gitorious.org/qtplayground/qtdesktopcomponents.git qtdesktopcomponents
git checkout qt5
qmake
make install
cd qmldesktopviewer; qmake; make; cd..
qmldesktopviewer/qmldesktopviewer examples/TopLevel.qml

Do you want to contribute? There are several open tasks, including:

  • Add a menu bar component
  • Add support for mouse wheel events
  • Style polishing on your favorite platform
  • Update: Tree View!

Finally, screenshot time (all on Qt 5):

Windows

Mac OS X

KDE

GNOME

117 Comments


Posted in KDE, Mac OS X, Qt, Windows

Recruiting Qt developers

Published Monday March 12th, 2012 | by

Many companies act like there is a great wall of China between professional developers and developer communities when recruiting. They don’t dare to tutor students, have interns or aid free software projects. They’re afraid, don’t see the benefits, and argue that everything should be kept separate.

In doing this they are dismissing an excellent way of recruiting top developers; dismissing the methods that have been used successfully by companies such as Canonical and Google. I’ve looked at some of the ways we’ve been hiring Qt developers.

Read more…

8 Comments


Posted in Community, KDE, Learning, Qt in Education, Qt in use, Uncategorized

Qt Contribution Day at Qt Developer Days

Published Monday October 10th, 2011 | by

The Qt community team has invited key Qt contributors to a Qt Contribution Day, which will happen in parallel with day one of Qt Developer Days Munich (October 24) and San Francisco (November 29).

The main goal of the days is for contributors to adapt and increase contributions to the Qt 5.X branch.

Pre-Dev.Days Code Sprint in Munich 2010

In Munich mostly KDE and Qt Webkit contributors have been invited, including Digia and some Qt maintainers. We are doing a similar day (unconference format) in San Francisco, inviting US-based developers who contribute to Qt. It’s a short trip to Dev Days especially from the Bay Area. Read more…

4 Comments


Posted in Community, Events, KDE | Tags: ,

Desktop Summit 2011 – the Free Desktop Invades Berlin

Published Sunday August 7th, 2011 | by

Early yesterday, organizers opened the second Desktop Summit in Berlin, with almost 1000 free desktop developers gathering at Humboldt University for the annual Gnome and KDE conferences. Two years ago, both communities held their conferences together for the first time, and decided to continue to cooperate again in 2011.

Desktop Summit Poster

Traditionally, we at Qt have had a close relationship with KDE, and again this year we are happy to be sponsoring the Desktop Summit.

The conference program is packed with presentations about all kinds of desktop technology for all audiences, from beginners to advanced developers, and – to my personal delight – there is a complete track of community related topics.

We are present with a couple of presentations in the program, with technical topics as well as community related ones. All presentations are recorded and will be made available online after the conference. So don’t worry if you can’t be here in person.

The conference is already well on its way, distros and repos are updated, I have spotted some Qt Ambassadors, and everybody is looking forward to a great event in sunny Berlin.

5 Comments


Posted in Community, Events, KDE | Tags: , ,

C++0x in Qt

Published Thursday May 26th, 2011 | by

While many are so enthusiastic about QML and javascript technology, a few of us still code in C++ ;-) . C++ is about to get an upgrade: C++11 (formely known as C++0x). The final draft was aproved last march in the C++ standard commitee, and the final specification is expected to be published this summer. If you don’t know it yet, I invite you to read specialized pages, such as Wikipedia or C++0x FAQ

One of the goals of C++0x is supposed to make the language easier. Which is hardly possible since it only adds more stuff to learn, but with the hope that the “mosty used” subset of C++ should be easier and more intuitive.

The good news is that you do not need to wait to use it. You can start today. The compiler you use probably already supports some of C++0x: GCC or MSVC 2010

While you can already use C++0x with older Qt version such as Qt 4.7, Qt 4.8 will come with more support for some of the new C++0x constructs:

New Macros

Some macros are defined if the compiler supports the new features

Q_COMPILER_RVALUE_REFS
Q_COMPILER_DECLTYPE
Q_COMPILER_VARIADIC_TEMPLATES
Q_COMPILER_AUTO_TYPE
Q_COMPILER_EXTERN_TEMPLATES
Q_COMPILER_DEFAULT_DELETE_MEMBERS
Q_COMPILER_CLASS_ENUM
Q_COMPILER_INITIALIZER_LISTS
Q_COMPILER_LAMBDA
Q_COMPILER_UNICODE_STRINGS

Initializer lists
Qt 4.8 adds new constructors to QVector, QList, and QStringList which enable you to initialize them using the bracket initializer.
You can now do

QVector<int> testsData { 1, 2, 10, 42, 50, 123  };
QStringList options = { QLatin1String("foo"), QLatin1String("bar")  };

which initializes the containers with those element.

Rvalues references and move semantics

Most of Qt classes are implicitly shared, meaning it is efficient to copy them if you do not modify them (copy on write). This is not the case for std::vector, where each copy implies copying all the data.
So if you have code like

std::vector<int> m_foo;
...
m_foo = getVector();

The getVector may construct a new std::vector, and return it as a temporary object, then the std::vector::operator= will delete the old content of m_foo, then copy all the data from the temporary vector to m_foo. At the end of the statement, the temporary vector will be destroyed, and its destructor will delete its data. It would be way more efficient if instead, the operator= would exchange m_foo data with the temporary vector’s data. That way, m_foo’s old data would be deleted when the temporary is destroyed, and we would not create a useless copy. This is what the move semantics in C++0x is, and it is achieved through rvalue references.

Even if copying an implicitly shared class is cheap, it does not come for free, we still have to increase and decrease the reference count, and the calls to the operator= cannot be inlined, since it accesses the private data. (We can’t inline that to ease binary compatibility).
So now, look at the Qt 4.8′s QImage move operator:

#ifdef Q_COMPILER_RVALUE_REFS
    inline QImage &operator=(QImage &&other)
    { qSwap(d, other.d); return *this; }
#endif

We just swap the internal data of the two images, this is a very cheap operation compared to the normal operation which requires a function call. We added this to most of the implicitly shared classes in Qt.
Since the operator= of all our containers is used a lot with temporaries, it may give small improvements to the speed of Qt, which might be a reason to compile Qt with C++0x support (see below).

Range-based for-loop

Qt had already a very convenient foreach, You can also find it in some other library, such as Boost.
The Qt foreach works with complicated macro, But C++0x goes further and make this construct part of the language.
So, instead of writing

foreach(const QString &option, optionList) { ... }

you can write

for (const QString &option : optionList) { ... }

There is a slight difference between the two: Qt does a copy of the container before iterating.
This is cheap for Qt container as they use implicit sharing, but is expensive with standard containers that do a deep copy of the whole content.
The C++0x range-based for does not copy, which means the behaviour is undefined if you add or remove items from the container as you iterate.
The new for will call the begin() and end() functions which are going to make a copy of the Qt container if it is shared and non const. Hence, it is better to pass const containers.

template<class T> const T &const_(const T &t) { return t; }
for(auto it : const_(vector)) { ... }

Lambda

We tested lambda with some of the QtConcurrent functions.
We tested it with QtConcurrent::run and QtConcurrent::map
But it does not work yet for QtConcurrent::mapped, we may fix that in the future.

So the scale example of the Qtconcurrent::map documentation could be rewriten like that

  QList<QImage> images = ...
  QFuture<void> future = QtConcurrent::map(images, [](QImage &image) {
            image = image.scaled(100,100);
        });

I am also researching using lambda in signal/slots connections, but that would be for Qt5.

Unicode Strings

We do not yet support the new string types. But that might come later.

Go and use it!

If you are using MSVC 2010, there is nothing to do, you can already use some feature such as the lambdas or the rvalue references.

If you are using gcc, you need to pass the flag -std=c++0x.
You can do that in your qmake project file like this:

QMAKE_CXXFLAGS += -std=c++0x

If you want to compile Qt using C++0x you can do

CXXFLAGS="-std=c++0x" ./configure

Qt compiled with C++0x is binary compatible with the good old C++. And you do not need to compile Qt with C++0x to write your own application using C++0x,

30 Comments


Posted in C++, KDE, News, Qt

  1. Pages:
  2. 1
  3. 2
  4. 3
  5. 4
  6. 5
  7. 6
  8. 7
  9. ...
  10. 32