The Trolls invite you to Oslo

Published Thursday January 29th, 2015 | by

QtCS_2015The Qt Contributors’ Summit 2015 now has a date, the weekend of 6-7th June 2015.

The event is aimed at people who contribute to Qt in any way; code, documentation, bug reports, support on the forums, wiki editing, articles on the web, Youtube videos. In short anyone who contributes to the Qt community is welcome.

This year the location will be the Qt Company offices in Oslo. The location offers a relaxed atmosphere for discussions with even a possibility to hack something together if needed, while still having good room for even large groups for presenting on different parts of the project.

As always the Qt Contributors’ Summit is the premier event to discuss the state and the future of Qt with the maintainers, approvers and contributors of the project. For those interested in the project, it is a must event.

The format of the event will follow the unconference style that has been successfully used in previous years. A wiki page will be set up where you can add your topic proposals prior to the event, and as the event draws closer the exact schedule will be crafted based on the proposals.

Showing app

QtCS 2014

The event will begin on Friday with an unofficial get-together / hack event at the Qt Company offices.

And as we will be in Oslo, we hope to see many old trolls attend the event.

The event is based on invitations, please register for an invite.

If you are into Qt, Oslo in June is the place to be.

 

P.S. if you are interested in sponsoring the event, please contact tero.kojo@theqtcompany.com to discuss the matter further.

Leave a comment


Posted in Community, Contributors, Events | Tags: ,

Robin Burchell, Qt Champion 2014

Published Wednesday January 28th, 2015 | by

QtChampion_logo_72dpi_RGB_color

This post is about Robin Burchell, one of the four 2014 Qt Champions, and how he came to the Qt community.

Robin was nominated in the Maverick-category, as someone who might not always follow the rules to the letter, but gets the job done.

Robin will be doing some guest posts here during the year too. He is an active blogger, and thought of some topics that would fit the Qt blog really well.

But back to today’s topic, Robin;

How I got interested in Qt

Back around 2007-2008, I was working as a web developer as my “day job”, but I wanted to start doing some desktop applications to meet my own needs. I had used Visual Basic years and years prior when I was still a Windows user, but I had since transitioned to Linux, so that wasn’t an option anymore. A good friend of mine recommended Qt to me, as he had been trying it out himself, and as I already had experience with C++ and was a fan of the language, I was pretty much right at home. I quickly got more and more involved in it, as I don’t really tend to do anything by halves – and when the Qt repository was open sourced, I quickly started trying to throw patches at it, because well, it’s a lot of fun.

My biggest projects

I tend to use Qt for lots of things in lots of ways. One of the biggest personal projects I was involved with was Nemo Mobile, an open source project orchestrated by a group of volunteers designed to use many of the open source components released by Nokia a few years ago around Maemo and MeeGo, and create an open source mobile phone stack and UI (middleware, a home screen and simple applications written in QML). You can see the sort of work that we accomplished at https://www.youtube.com/watch?v=DHpdI_BW6aA. Later, I (and a lot of other contributors around the project) ended up working with Jolla on what became Sailfish OS – the Qt and QML powered operating system.

Of course working on Qt itself has probably been my biggest project. Something which I have continued to work on all along. :-)

My Qt Loves

I’ve shifted around a lot of Qt over time. Initially, my interests were primarily inside QtCore, QtNetwork, and widgets — but more recently, that has shifted. I’ve spent a lot of time reading around QPA (the Qt Platform Abstraction), and things like touch input. Touch is another area dear to my heart, I’ve worked on some of the plugins getting touch input into Qt through different sources such as TUIO and on touch handling in QtQuick – another thing I love.

Performance and resource usage is something I find really important, so that’s something I love to focus on – and I also find it a lot of fun. Most recently, I’ve been looking at how to make QtQuick-based applications faster and slimmer than ever (with a lot of help from others), and hopefully some of that work will start to spread its wings for Qt 5.5. More on that some other day :-)

Memorable Moments

My happiest moments have come at the delivery of each subsequent Qt release containing thousands of hours of work from the partners and community to make things a bit better each time. It’s a rare thing that a project with such a large scope can continue to get better at the pace it does, and I’m very happy to see that it shows no signs of stopping. My most memorable moment in recent times, though, would have to be spending a very pleasant afternoon in a beer garden in Berlin just before the opening of the Qt Contributors Summit in 2014…  (it was an exceptionally hot day for June in Berlin, over 30 C in the shade, and around the table were quite a number of key Qt contributors just chatting and having fun)

…and getting nominated as Champion of course, for which I am very humbled. :-)

The best thing about the Qt Community

… would have to be how approachable it is. There’s plenty of helpful people in many fields happy to help out, whether you just need advise on how to best write an application, or to contribute to Qt itself, you’ll almost always find someone happy to help. There’s a great community on IRC, a lot of helpful people on forums, etc. That, together with the great documentation and resources has always given me the impression that Qt is something that is really quite easy to pick up and approach and extend.

I also love how Qt is available as an open source project, so that it can be fixed or improved on by anyone out there. With so many commercial products, that simply isn’t possible, meaning that even if you have the time and skill to fix a problem you run into, you can’t. You’re stuck.

Leave a comment


Posted in Uncategorized

Dyami Caliri, Qt Champion 2014

Published Tuesday January 27th, 2015 | by

QtChampion_logo_72dpi_RGB_color

Dyami Caliri is a Qt Champion 2014 in the category of ‘Rookie of the year’. The title is given to someone who has made their first code contributions to Qt in the previous year.

In Dyami’s case his patches had caught the eyes of maintainers for their high quality in areas where new contributors aren’t usually seen.

As it turns out, Dyami isn’t a beginner in the Qt world, but works with a major professional application built with Qt (and he is very modest as you can read below).

His contributions back to Qt are a great example of how scratching your itch works.

Dyami, do you still remember how you got interested in Qt?

We have a small company and that makes stop motion software and hardware geared towards professionals. Our program, Dragonframe, was originally written in Java over the course of several years. We supported Mac and Windows. I felt like we were running into several issues with using Java, from performance and maintainability, to public perception and vendor support–that would be solved by using a C++ cross-platform framework. So I did a lot of research and toying around with different frameworks, and found Qt really satisfying. It had a lot of functionality, was well-documented, was actively developed and supported, and had a good developer community.

What are the biggest projects you’ve done with Qt?

Clearly Dragonframe. It is software for stop motion filmmaking, geared towards creative professionals and studios. You connect a supported DSLR to the computer, and Dragonframe shows you a live video image from the camera, can control exposure settings, and capture and download images. There are a lot of additional tools such as DMX512 lighting integration, motion control programming, and audio lip-synching. Our software is used by major studios to capture stop-motion films.

Aside from Dragonframe, we have a small network license server that I also rewrote in Qt.

(Sidenote: it really is worth visiting the Dragonframe homepage to see who is using Dragonframe and also take a look at how Dragonframe works, it’s a really great looking pro application.)

How did you get into contributing to Qt? Was it scratching your own itch or something else?

It was definitely to address some issues we were running into. But then I started looking through bug reports for anything that might affect our software. I also participated in the Qt Fix and Polish week and just tried to fix anything I could.

Is there something you are looking forward to in the next releases of Qt?

Just continued support and improvement for the latest Mac and Windows OSes.

In your view what is the best thing in the Qt community?

There a lot of people, both inside the Qt Company and outside, that want the framework to be great, and constantly working to improve it.

Leave a comment


Posted in Community | Tags: ,

Qt Weekly #24: High-dpi QtWayland

Published Tuesday January 27th, 2015 | by

Those of you following QtWayland development closely might have seen commit 7ef5e2e4 – Implement high-dpi support. In this blog we’ll look at some examples and show how to test the support on high and normal dpi hardware.

Wayland

Wayland 1.2 added support for high-dpi scaling via

  • wl_output::scale
  • wl_surface::set_buffer_scale

wl_output::scale is used by the compositor to inform the client that it will scale buffers by the given scale factor (presumably because it is compositing to a high resolution display). The client then has the option of providing high resolution buffers and bypass the compositor scaling. This is done by calling set_buffer_scale (and then actually creating larger buffers). Typical values for the scale factor is 1 and 2; Wayland supports integer factors only. From he client point of view the buffer sizes are the only thing that changes with the scale factor, other wl_surface geometry is not multiplied by it.

Qt

Creating larger buffers and rendering high-dpi content is handled internally by Qt using the existing devicePixelRatio implementation. This implementation is also in use on OS X and iOS, and – via the QT_DEVICE_PIXEL_RATIO environment variable in Qt 5.4 – in experimental form on X11 and Windows. The details of this mode have been covered elsewhere; the main thing to be aware of as an app developer is that you need to provide high-resolution raster artwork, and that raw OpenGL are in device pixels and see the full display resolution.

Weston

Recent versions of the Weston compositor (I’m using 1.6.0) supports running in scaled mode:

./bin/weston --width=640 --height=480 --scale=2

We can then launch any Qt app, as usual:

./anyqtapp -platform wayland
high-dpi and normal-dpi rendered Flat style demo

high-dpi and normal-dpi rendered Flat style demo – best viewed at full size

The screenshots illustrate the benefits of the devicePixelRatio scaling mode: The application is automatically rendered at a higher resolution; no modifications to app code is needed. In cases where high-resolution content is not available there is a graceful degradation to low-resolution content, without breaking layouts or by displaying “small” user interface elements.

High-dpi support is currently implemented in the “dev” branch of QtWayland and are on track to be released with Qt 5.5.

Leave a comment


Posted in Graphics

Blog on Qt 3D 2.0 from KDAB

Published Monday January 26th, 2015 | by

Sean Harmer of KDAB has written an excellent two part blog entry on the upcoming Qt 3D 2.0. In the first part he goes in to what a modern 3D engine should be able to do and then goes on to explain the high level architecture and principles of Qt 3D 2.0. In the second part he shows some examples and gives an update on the current status of Qt 3D 2.0. Go and read both, they are very informative and give a glimpse to what’s coming in 3D side of things to Qt.

6 Comments


Posted in Qt 3D, Qt Quick 3D

Introducing the Qt Quick 2D Renderer

Published Thursday January 22nd, 2015 | by

When Qt Quick 2 was introduced with the release of Qt 5.0, it came with a minimum requirement of either OpenGL 2.0 or OpenGL ES 2.0.  For desktop and mobile platforms this is usually not an issue, and when it is for example on Windows, it is now fairly easy to use an OpenGL software rasteriser as a fallback.  If however your target is an embedded device without a GPU capable of OpenGL ES 2.0, then software rasterisation of OpenGL is an unwise option.  It is typical that the embedded devices without a GPU have less CPU resources available as well, so the overhead introduced by the software rasterisation of OpenGL leads to unacceptable performance for even the most simple content.  Also many of the performance optimisations gained by using OpenGL for rendering Qt Quick 2 scenes are negated by software rasterisation.

So as a solution to our Professional and Enterprise customers we are now providing an alternative scene graph renderer called the Qt Quick 2D Renderer.  The Qt Quick 2D Renderer works by rendering the Qt Quick scene graph using Qt’s raster paint engine instead of using OpenGL. Read more …

10 Comments


Posted in Embedded, OpenGL, Qt Quick 2

Qt Weekly #23: Qt 5.5 enhancements for Linux graphics and input stacks

Published Tuesday January 20th, 2015 | by

The upcoming Qt 5.5 has received a number of improvements when it comes to running without a windowing system on Linux. While these target mainly Embedded Linux devices, they are also interesting for those wishing to run Qt applications on their desktop machines directly on the Linux console without X11 or Wayland.

We will now take a closer look at the new approach to supporting kernel mode setting and the direct rendering manager, as well as the recently introduced libinput support.

Read more …

6 Comments


Posted in Embedded, Graphics, OpenGL, QPA

Nice Blog Post From Boundary Devices

Published Friday January 9th, 2015 | by

Check out this nice blog post about Qt for device creation written by Eric Nelson from Boundary Devices. The post nicely summarizes what Qt for device creation is all about. You can also find an easy to follow step-by-step guide on how to use the BYOS (Build Your Own Stack) tooling which is provided as a part of Qt for device creation offering.

Comments Off


Posted in Uncategorized

Two more Qt Champions for 2014

Published Monday December 22nd, 2014 | by

QtChampion_logo_72dpi_RGB_colorThe year is coming to an end, but Qt Champions continue to make Qt better for everyone!

I’d like to welcome two more Qt Champions for 2014, Robin Burchell and Dyami Caliri!

Dyami is a professional Qt developer, but has started contributing to Qt itself very actively in 2014, and thus will be awarded the Qt Champion title in the category of ‘Rookie of the Year’.  You can find Dyami’s code in the Qt base and serial port implementations, not easy places to get started on.

Robin (or w00t for those of you on IRC) is a more familiar name to many Qt contributors, during the past years he has worked on quite a lot of things in Qt. This year he has made an impact in Qt Wayland among other things. Robin is being awarded the special title of Maverick, as he is someone who does not always go by the book, but will get the job done.

Robin and Dyami will be getting their customised prizes and a one year Qt professional license. Please join me in congratulating our new Qt Champions!

With these two awards, we will be closing Qt Champions for 2014. More champion titles will be awarded in the Autumn of 2015, when we will see who has amazed us then.

Comments Off


Posted in Community, Contributors | Tags: ,

Qt 5.4 released

Published Wednesday December 10th, 2014 | by

I am happy to announce that Qt 5.4 has been released today and is available for download from qt.io. Together with Qt 5.4, we have also released Qt Creator 3.3 and an update to Qt for device creation on embedded Linux and embedded Android.

But let’s start with Qt 5.4. One of the main focus areas of this Qt release has been around Web technologies and we have a lot of cool new things to offer there.

Renewed Web Story

HTML5 and Web technologies have become more and more important over the last years, and we have spent the last year developing a completely renewed Web offering for Qt. The Qt WebEngine module is the result of a long-term R&D project where we adopted the Chromium Web engine for use within Qt. With Qt 5.4, it is fully supported on the most used desktop and embedded platforms. Qt WebEngine provides you with an easy-to-use API to embed Web content in both Qt Widgets and Qt Quick based applications.

The new Qt WebChannel module provides a simple-to-use bridge between QML/C++ and HTML/Javascript. This enables the creation of hybrid applications that use both Qt and Web technologies. Communication between both sides happens by exposing QObjects in the Web context. The module works not only with Qt WebEngine, but also with any other browser engine that has support for Web sockets.

As a third component, Qt 5.4 introduces a Technology Preview of a new module called Qt WebView. The Qt WebView module offers a more limited API to embed the web browser that is native to the underlying operating system for use cases where the full Qt WebEngine isn’t needed, or where it can’t be used because of restrictions coming from the underlying OS. In Qt 5.4, the Qt WebView module supports iOS and Android.

Together with the Qt WebSockets module introduced in Qt 5.3, Qt now has great support for many of the latest Web technologies and makes interacting with Web content very easy. Qt WebEngine and Qt WebView make it very easy to embed HTML5, Qt WebChannel creates the communication channel between Qt and HTML5 that is required for hybrid applications, and Qt WebSockets allows for an easy communication between Qt and many Web services.

Qt 5.4 also still contains the older Qt WebKit module. Qt WebKit is still supported, but as of Qt 5.4 we consider it done, so no new functionality will be added to it. We are also planning to deprecate Qt WebKit in future releases, as the new Qt WebEngine provides what is needed. In most use cases, migrating from Qt WebKit to Qt WebEngine is rather straightforward. If you are starting a new project that requires web capabilities, we advise that you already start using Qt WebEngine.

Qt for WinRT | Completing our Cross-Platform Offering

The second big new feature of Qt 5.4 is the completion of our cross-platform story with the full support for Qt on Windows Runtime. Qt for Windows Runtime was already added as a supported Beta to Qt 5.3, and has now reached the state where it is a fully supported part of Qt. With Qt for Windows Runtime, you can create applications for the Windows Store, targeting both Windows Phone 8.1 and above as well as Windows 8.1 and newer.

Read more …

56 Comments


Posted in KDE, News, Qt

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