Room: Almaty A

Red Herring – QML nd HMTL5

Presenter:Till Adam

Abstract:
As part of a bigger debate raging through the internet at the moment, about what set of technologies is “best”, when it comes to building applications of various kinds for various domains, the question “Should I use HTML5 or Qt” is often asked. The presentation will attempt to do away with the notion that that is even a valid question and that there is a sensible choice either way. This, I believe, is the technological red herring of our time, and it needs to be exposed.

Presenter Bio:
Till works at KDAB where he is responsible for the services business. He misses programming, playing the guitar and working with literature, but enjoys working with the smartest team in the business and taking care of his five year old daughter. He lives in Berlin.

QML gotchas

Presenter:Aurindam Jana

Abstract:
Show some common mistakes when coding in QML.

Presenter Bio:
Aurindam has an engineering degree in Electronics and Communication. He has spent the last seven years developing software for mobile platforms. He has been using Qt for more than four years and has been contributing to both Qt and Qt Creator. He also codes on iOS during his free time.

The Raspberry Pi Camera Module

Presenter:Jeff Tranter

Abstract:
This lightning talk will describe the features of the official camera module for the Raspberry Pi, how to install and configure it, and how to use the applications available for it. It will describe current work being done to develop V4L (Video 4 Linux) drivers, and discuss some recent interesting projects that have used the camera.

Presenter Bio:
Jeff Tranter is a Qt Consulting Manager at Integrated Computer Solutions (ICS). At ICS, Jeff is responsible for the management of customer software projects, including the architectural and high-level design of software systems. Prior to joining ICS, Jeff was one of the founding members of Xandros Corporation where he managed a team of developers responsible for the desktop components of Linux-based Xandros Desktop products. Jeff has written a number of books on Linux and Open Source programming as well as numerous magazine articles and has given presentations at conferences and user groups.

Using QVariant printing capabilities along with some syntactic sugar for simple string formatting

Presenter:John Melas

Abstract:
Although I like QString formatting capabilities I was looking for a way to write:

QString name = "John";
int age = 38;
QString s = S("Name: %1, Age: %2",name,age);

where S() is a function or macro that does all the magic.

Solution:

class VA : public QList
{
public:
VA(const QString & fmt) : m_format(fmt)
{
}

VA & operator , (const QVariant & v)
{
append(v);
return *this;
}

QString toString() const
{
QString s = m_format;
foreach(const QVariant & v, me)
s = s.arg(v.toString());
return s;
}

protected:
QString m_format;
};

Now we can write
QString s = (VA("Name: %1, Age: %2"),name,age).toString();

But the C++ compiler supports macros with var args.
#define S(fmt,...) ( (VA(fmt), ##__VA_ARGS__).toString() )

So now we can write:
QString s = S("Name: %1, Age: %2",name,age);

I think this is a great solution because it combines some nice C++ tricks
together with the printing capabilities of QVariant to format strings!
It can print QColor, QDate, QDateTime etc variables out of the box
while this is not possible with QString::arg methods.

I believe that if Qt adds more functionality to QVariant::toString
(for example functionality that already exists in QDebug class)
this solution will be even more powerful in the future!

Presenter Bio:
My name is John Melas I am 38 years old and I live in Athens, Greece. I have studied Electrical and Computer Engineering in National Technical University of Athens Greece. I have worked in several companies including Siemens and Unibrain as a software engineer. I have more than 10 years experience in C++/MFC and 4 years experience in Qt. Since 2012 I am an independent software developer and I program database and music applications using C++/Qt. I have developed and sell a complete software suite (Editors and Librarian) for the Yamaha Motif series of synthesizers. You can find demos of my work at my web site: http://www.jmelas.gr/motif I am very interested in porting my applications to iOS using Qt5/QML

Quick and physical (adding simple mechanical interactions to your QML)

Presenter:Vladimir Moolle

Abstract:
While qml is a natural choice for playground-style interactive applications (it has animations, states, etc), the interactions between on-screen items are explicitly driven by the logic in the event handlers, with a slight exception for the Particles module.

What many would probably like to have at hand is a means to:

  • add bi/multi-directional geometric constraints on groups of items (one of
    the first things a novice QML programmer learns is that anchors are
    uni-directional, being just an (optimized) bindings flavor)
  • have simplistic spring-mass interactions between some of the items in the
    scene, with gravity and friction forces preferably applied as well
  • have very basic collision detection for the on-screen items

Being no substitute for a “serious” simulation logic, or even a “stock” game
physics engine like Box2D or Bullet, the above would still be useful for many
simpler applications.

The talk proposes a solution which builds on the strengths of QML and fits
into its standard ecosystem naturally.

Presenter Bio:
Vladimir Moolle is a Qt/QML software developer for Integrated Computer Solutions, Inc. (ICS), with a specialty in QML, and also a co-author of the ICS “Effective QML” training course. Vladimir has a specialist degree in mechanical engineering from the Baltic State Technical University, Russia.

Room: Almaty B

The QML runtime

Presenter:Alan Alpert

Abstract:
Introducing the QML runtime, finally allowing QML-only applications to officially exist. Generic and versatile, this is what qmlscene should have been from the start.

Many applications will still be large enough to want C++ integration, and many platforms will not encourage purely interpreted applications, so C++ will still be the primary entry point. Many of the conveniences of the QML runtime arrived as C++ conveniences first. But here is finally the proper way to write those little script applications, or simple test cases, in pure QML.

Presenter Bio:
Alan has been developing Qt since he was a Trolltech employee, and was a member of the original Brisbane team which developed QML. His mission, continuing in Blackberry, is to support the creation of modern and pixel-perfect mobile UIs using Qt and QML. He is currently the QtQuick maintainer and spends most of his time developing further QML and QtQuick features.

CalendarApp (QtOnAndroid) and DesktopApp (Qt) using GnuPG and sync via Drupal Services

Presenter:Christoph Hagemeyer

Abstract:
It all began in October 2011 in Cologne, Germany. The idea was simple, my calendar data should be easily viewable via Thunderbird as well as an AndroidApp and under no circumstances should they have to be synchronized with Google. Furthermore the data should, whenever possible, be transmitted in a secure way by means of end to end encryption. At the same time I wanted to get to know QtQuick which had just begun to gain momentum. By now the Android app is running on my Samsung Galaxy S3 Mini and transmits the data via Drupal Services (JSON) to my PC. The apps data are encrypted and decrypted on the device by use of PGP. The self-developed app is run on the mobile device and the ical files generated by the app are imported to Thunderbird Lightning on the PC. Currently the app is still in a very early beta state. The planned launch of a public beta version is set for December 2013. A video which gives a first impression can be found here: www.gnuty.org

Presenter Bio:
Christoph Hagemeyer is a software engineer and works for almost three years with a focus on C++/Qt, IT Security and Embedded Systems. He holds a Diplom-Informatiker (FH) graduate degree as well as a master’s degree in computer science and worked at the university in the past with a focus on it security and graphical user interfaces with Qt. Current focal point of his work is Qt on embedded systems with Nvidia Tegra and Toradex Colibri ARM. He has a big passion for free software and open source.

Banana accounting spreadsheet software

Presenter:José Del Romano

Abstract:
Success story: porting a windows based application to QT and making it Crossplatform. The ideal accounting software for small companies, non-profit organizations, churches, the self-employed, etc.

Presenter Bio:
I’m a developer at Banana.ch SA, I had my first approach with programming in High-school. I Studied Software engineering at HES Yverdon-les-Bains (CH). I started using QT in 2010, and I love it.

How do we write SQL queries in 2013?

Presenter:Andras Mantia

Abstract:
SQL queries were traditionally written as strings and QtSql is no different from that. This is ugly and very error prone. There is hope: with the help of experssion templates and some other goodies we can avoid strings to a great extent and write SQL code that is validated at compilation time or at least deals with objects and not strings. Shortly: introducing SQLate, the template based SQL access for Qt.

Presenter Bio:
Andras is a Qt and KDE developer since 2001, working on KDE software like Quanta Plus and Kontact. He is currently employed by KDAB as a senior software engineer, working from his home office in Romania. The projects he is involved are various types ranging from specialized tools on desktop to multi-platform applications that work both on desktop and mobile devices. He is also a Qt trainer, giving trainings for customers throughout Europe. He is still involved in the KDE project.

How to use Facebook, Ads, In-App Purchases and Analytics in mobile Apps with Qt

Presenter:Christian Feldbacher

Abstract:
Do you want to use Facebook, ads or Flurry analytics in your mobile app? What if you could access them easily from QML in less than 10 lines of code? In this talk I’ll present the Qt Quick plugins we created to monetize, analyze and increase visibility of your mobile apps in the booming iOS & Android app stores. I also cover how to use in-app purchases from QML, the most successful way to monetize your apps.

To round off this talk, I’ll share exclusive details about the world’s first Qt-based gaming backend to keep your users return to your app and highly motivated. I show how you can use gamification in your mobile and desktop apps and how to keep your users engaged.

Presenter Bio:
Christian Feldbacher is Co-Founder of V-Play GmbH. He has more than 10 years’ experience in software development with a strong focus on game and mobile app development for all kinds of platforms including native Symbian, Java ME, iOS, Android, MeeGo, and BlackBerry. After 10+ years C++ and 5+ years Qt C++ development, Christian was overwhelmed by Qt Quick and the combination of performance and code efficiency. His passion for games and experience in Qt, game, and mobile platform development led to the creation of V-Play Game Engine which was publicly launched in January 2013. Besides working on V-Play, Christian joins game jams and teaches university students how to develop with Qt.

Room: Moskau

fullmo Kickdrive – Qt Quick in Industry Automation

Presenter:Oliver Heggelbacher & Frankie Simon

Abstract:
Or: how to give users a dynamic playground, while hiding away the complex machinery behind it.

The Kickdrive software platform is a multi-layered and multi-language approach to industrial machine configuration and control. Qt Quick allows for beautiful and highly adaptable user interaction on top of a C++/QWidget application. In Kickdrive, the QML files are part of the project data – something that comes as a ready-to-use template, but the users can hack and change it to their liking. They touch up, tweak and extend their project UIs, evolving into co-developers of sorts.

We will show off how we cross boundaries and connect the dots: from the Qt Quick UI via Python Scripting, a C++ multithreaded signal-slot logic, Windows USB and finally the actual industrial field bus communication. To make things move in real life.

Oh, and we’ll bring along some gear.

Presenter Bio:
Oliver Heggelbacher is a managing partner of Flachmann & Heggelbacher, the makers of www.docklight.de and www.kickdrive.de. He builds reliable and easy-to-use software for engineers, and discovered Qt in 2005. Originally from South Germany, he lives and works both inside and outside his home country. He is known to pick up a guitar and sing.

Frankie Simon is a software engineer, working with the Qt platform and previously with .NET. Born in Lithuania in 1983, living between Israel and France, he is also a pianist and speaks five languages. His allergy to cats has disappeared two years ago.

Remote Debugging With GammaRay

Presenter:Volker Krause

Abstract:
Until now the Qt introspection tool GammaRay has been running inside the inspected host process, effectively limiting its use to widget-based projects on the desktops, or projects that could be run in that configuration somehow. Not anymore! We are going to see how the upcoming GammaRay 2.0 allows you remote debugging of embedded devices or introspection of non-UI Qt applications.

Presenter Bio:
Senior Software Engineer at KDAB, Volker has been developing with Qt for more than ten years now. He works in Berlin’s KDAB office as a team lead, consultant and trainer. His experience with Qt spans desktop and embedded platforms, with a focus on software architecture and tooling. He has taught many ‘Programming with Qt’ trainings throughout Europe and is a long-term contributor to the KDE project. In 2010 Volker started the GammaRay project to address the need for QML debugging tools (which did not yet exist at this time), and has lead the project since then.

Data Visualization in 3D

Presenter:Sami Makkonen

Abstract:
At Digia we have been thinking about the evolution of data centric user interfaces and how to utilize the power of Qt 5 and 3D technologies. In this talk we present the current state of the 3D data visualization library we have been developing. One thing we noticed when we started the development was that 3D has been used in data visualization for some time now but it is quite seldom truly utilized. Most common use case is to draw 3D like bar charts in order to increase the visual look & feel of the data presentation. However in many cases the 3D presentation does not bring any real value and in several cases it actually makes it harder to read the data. Combining user interaction and real time 3D drawing enables us to create user interfaces that are efficient in UI space consumption and by introducing different kind of mechanisms for fluently changing between 3D and 2D presentation we can truly utilize the value of 3D in visualizing data.

Presenter Bio:
Sami is working at Digia, Qt R&D as Senior Manager and his focus is in Qt Developer Experience related matters e.g. Qt documentation. Sami has been also leading the development of Qt Enterprise Charts library. Sami holds an M.Sc.(Econ.) degree in Computer Science from the University of Jyväskylä. Sami has been working in Digia for 16 years in different roles from development to program and product management.

Easy Qt Development on embedded devices with Hemera

Presenter:Dario Freddi

Abstract:
Developing on embedded devices can be a pain, and achieving results may need a set of competencies which overwhelms the simplicity of the final application. So, what if developing an application for your favorite board was as easy as developing a mobile application? Hemera, leveraging the solid foundations of Mer and a custom middleware system in Qt5, makes Qt5 and Qt4 development on embedded devices fast, productive… and fun! Find out what’s inside and outside, and how to get your QML application running in the time span of a lightning talk.

Presenter Bio:
Dario Freddi found his love for Qt by being strongly involved in several open source projects since his early years – in particular KDE, to which he started contributing in 2007, and never stopped. From there on, he signed up as a Qt Ambassador and specialized in freedesktop.org technologies integration, writing Qt bindings to several open source frameworks such as polkit and Telepathy.

He is a regular speaker to some of the most important Open Source conferences worldwide, usually on Qt-related topics.

Qt has been an integral part of his academic and work life since forever – his degree in Information Engineering came with a thesis over an abstract communication system for musical devices completely built on top of Qt. Afterwards, he worked as a freelance consultant for several important companies around the globe, and nowadays he runs Ispirata, a company providing services and products built around KDE and Qt technologies.

Qt Quick Enterprise Controls

Presenter:Hanne Linaae

Abstract:
Qt Quick Enterprise Controls are planned to be an extension of the Qt Quick Controls that were introduced in Qt 5.1. The idea is to introduce a set of more complex, enterprise-level, possibly even industry-specific, pre-built Qt Quick UI controls. In this talk we will show you some prototypes of controls that we have started to work on, and also talk about other ideas we have.

Presenter Bio:
Berlin:
Jens Bache-Wiig is a Senior Software Engineer at Digia and holds a M.Sc. in computer science from the Norwegian University of Science and Technology (NTNU). He is a pixel perfectionist and likes to focus on styling, platform integration and improving Qt Quick.

San Francisco:
Hanne Linaae
Hanne has been part of the teams behind and around Qt since way back when – in many different roles. She is now part of Digia’s R&D management team, especially focusing on Qt Quick Controls, Qt for iOS, UI and graphics.

Room: Asgabat

Cheap radio control for electronic timing systems using Qt, BlackBerry 10, and Raspberry Pi

Presenter:Kalle Dalheimer & Benoit Dumas

Abstract:
Portable electronic timing systems are used in many sports, including cross-country skiing, biathlon, orienteering, and multisport, as well as in school PE activities. However, this equipment is rather expensive, which makes it unaffordable for many volunteer-run sports clubs and tax-funded schools. In this talk, we present a homegrown radio control component based on a BB10 phone and a Raspberry Pi, all running Qt-based software, of course.

Presenter Bio:
Kalle Dalheimer is the President and Founder of the KDAB Group. Benoit Dumas is a Software Engineer with KDAB. Both are avid orienteers who are always looking out for new ways of using technology to improve their favorite sport.

What’s new in QDateTime and QLocale

Presenter:John Layt

Abstract:
Qt 5.2 will introduce a number of changes to QDateTime and QLocale, with more changes planned for Qt 5.3. This talk will introduce the new features available for developers, some new restrictions, and discuss the plans for the future.

Presenter Bio:
John Layt is a member of the KDE Community involved in the KDE Frameworks 5 work, a contributor to QtCore, and maintainer of QtPrintSupport.

Fancy video effects with QtGStreamer and Qt Quick 2.0

Presenter:Mathias Hasselmann

Abstract:
QtMultimedia provides nices options for video playback. For most cases it’s the obvious choice. Still there are those days when your boss asks for fancy features that need crazy tricks. That’s where GStreamer comes into play.

This short demo will give a glimpse of what becomes possible when integrating custom GStreamer pipelines with Qt Quick 2.0.

Presenter Bio:
Mathias is a passionated, professional software developer at KDAB, writing Linux code for almost one and a half decade. Before joining KDAB he worked at Openismus, implementing personal information components for Nokia’s Maemo and Meego phones. Even earlier he dealt with scientific software at the Max-Delbrück Center for Molecular Medicine.

Implementing moc using clang’s libraries

Presenter:Olivier Goffart

Abstract:
Every Qt C++ developers run moc. Many of us see its presence when it is not working well because of a parse errors or one of its limitation. Clang offers more than a compiler, but also a set of libraries that can be used to make a C++ parse, which is exactly what moc needs. Could clang be used for moc? What would the benefits be?

Presenter Bio:
Olivier Goffart started working with Qt 10 years ago with his involvement in KDE. He was then hired by Trolltech to work on Qt in 2007. He has been working on various areas of Qt including the itemview framework, the widget stylesheets, QtScript, the QObject internals, and the QML debugger for Creator. He is now the co-founder of Woboq, a company based in Berlin focussing on Qt.

QtCreator for BareMetal development

Presenter:Tim Sander

Abstract:
QtCreator has a new BareMetal-Plugin for Developing on really small µC with a few KB of Ram and Flash.

This talks gives an hand’s on overview how the BareMetal Plugin can be used.

Presenter Bio:
The Presenter has a “Diplom” in Computer Science and works in the embedded software development.

Room: Vilnius

Accessing Android System Services with Qt for an Aircraft

Presenter:Walter Roth

Abstract:
The GlasscockpitQML application shown in this talk is a backup instrumentation for small aircrafts. It was ported from MeeGo to Android using the Necessitas suite which supplies sensor, location and mapping services. Because of the high update frequencies required, a direct access to the Android LocationManager was necessary. A Java GpsService adapter class written for GlasscockpitQml uses Android’s LocationManager to access the phone’s GPS receiver. It communicates with a C++ class called AndroidQtGpsService through a set of native (JNI) functions.

The AndroidQtGpsService .cpp file contains the counterparts to the native Java functions as a set of C (extern C) functions calling member functions of the QObject subclassed AndroidQtGpsService class to dispatch the informations to the rest of the a

pplication through Qt-signals. A workflow for creating suitable testprograms for the various steps in the development process is suggested.

The technology demonstrated here can easily be adapted to access other services on the phone using e.g. Android Intents to get images from the camera.

Presenter Bio:
Walter Roth was born in 1952. He received his Diploma degree in Electronics from Hannover University in 1977 and his Ph.D. From RWTH Aachen in 1982. From 1984 to 1989 he worked with ELMOS semiconductor AG in Dortmund. Since 1990 he works as a professor at University of Applied Science Suedwestfalen, Iserlohn, Germany. His main interests are in C++ programming for IT security, computer graphics and sensor applications.

Command-line parsing in Qt

Presenter:David Faure

Abstract:
For a long time Qt developers have been missing a command line parser in Qt. Many tried, and gave up due to the amount of bikeshedding involved. It was even an April fool’s joke within Trolltech, specifying the features that it should have – including a plugin system for additional features! Qt 5.2 finally comes with QCommandLineParser. I’ll present its API and features quickly.

Presenter Bio:
KDE developer since 1998, David Faure works at KDAB since 2003, on various development projects, as a Qt trainer and consultant, and nowadays as managing director for the french subsidiary. After working on Konqueror and KOffice, he is now one of the main contributors and maintainers of the KDE 4 libraries. He architects many of the changes required for the modularization effort called KDE Frameworks 5, and since Qt adopted an Open Governance model, he contributes regularly to Qt 5, particular in QtCore.

QML’s many faces

Presenter:Kevin Krammer

Abstract:
QML is very often considered to be just an implementation detail of QtQuick, a UI framework for Qt applications with an initial focus on mobile devices. However, QML is actually way more than that. It is a declarative language and associated runtime which can be used for any number of scenarios that benefit from its features.

This talk will show some of those lesser known use cases and should give the audience the necessary base information to explore sure usages in their own projects.

Presenter Bio:
Kevin is a developer and Qt trainer at KDAB and has been actively using Qt since 2000. He has been an active KDE contributor for the same time and is also one of the founding members of the Qt community site QtCentre.

News from Inqlude, the Qt library archive

Presenter:Cornelius Schumacher

Abstract:
What if there would be one place where developers could find all Qt libraries?

What if there would be one place where authors of libraries could publish their libraries to all Qt developers?

The goal of the Inqlude project is to make this happen. It’s an open, crowd-sourced archive of Qt-based libraries, which presents the libraries on the web and provides tooling to access and integrate the data and download sources or binaries ready to use. The goal is to have a complete archive of all libraries based on Qt.

In the presentation I’ll show what is there today, and where we want to go.

The current web page of Inqlude is at http://inqlude.org.

Presenter Bio:
Cornelius Schumacher is a Qt user since Qt 1.1. He is a core contributor in the KDE community since 1999 and has authored and maintained a significant number of Qt and KDE applications and libraries. Currently he serves as the president of KDE e.V., the non-profit organization behind the KDE community. Cornelius works for SUSE in Nürnberg.

Extending Your Qt Widget Desktop Application as a Back-end Service for Web and Mobile Devices

Presenter:Cameron Kiddle

Abstract:
Traditional Qt Widget based desktop applications play an important role in many industries, but with the demand to work in different places and on any device, the way in which users access applications is changing. Transitioning from a desktop application to a multi-platform mobile application is challenging, particularly if your application works with big or sensitive data that is unreasonable to transfer to client devices, or involves high performance processing/rendering that requires certain hardware.

The PureWeb SDK lets you extend your Qt Widget desktop application to become a back-end service accessible from web and mobile devices. The business logic of your application is preserved without having to rewrite it and your application can continue to run on the hardware it does now with data remaining secure on the server side. JavaScript APIs are available to create thin clients that expose views and functionality from your back-end service that can be adapted to best suit the form factor and capabilities of target devices.

This presentation provides an overview of the back-end service extension process and illustrates real world examples of where it is in use today in medical imaging, oil & gas, simulation & training, and other areas.

Presenter Bio:
Dr. Cameron Kiddle is a Senior Product Manager at Calgary Scientific Inc., a company specializing in medical imaging and web/mobile/cloud enabling software. He is also an Adjunct Assistant Professor in the Department of Computer Science at the University of Calgary. Dr. Kiddle is co-author on over 30 refereed journal and conference papers in the areas of cloud computing, high performance computing, grid computing, virtualization, social networking and simulation. Prior to working at Calgary Scientific, Dr. Kiddle was Technical Director of the Grid Research Centre at the University of Calgary. He was also Distributed Systems Architect for WestGrid, a High Performance Computing consortium of 14 institutions in Western Canada.

Dr. Kiddle has had extensive experience speaking at events around the world over the past 10 years. This includes presentations at Analytics, Big Data and the Cloud (2012-Edmonton, 2013-Calgary), TERENA Networking Conference (2011-Prague), Square Kilometre Array (SKA) Meeting (2011-Banff), PrepSKA Meetings (2010-Oxford, 2011-Manchester), Open Grid Forum (2010-Munich), Cybera Summit (2008, 2009, 2010-Banff), GCE Workshop at Supercomputing (SC) (2009-Portland, 2011-Seattle), HP Software University Association Workshop (2007-Munich, 2008-Morocco), Symposium on Frontiers in Networking with Applications (2008-Okinawa), Winter Simulation Conference (2005-Orlando), and the Workshop on Parallel and Distributed Simulation (2003-San Diego, 2004-Austria).

How to create a CoverFlow in QML

Presenter: Igor Grivko

Abstract

This talk is going to describe how to create a CoverFlow in QML. The simple example shows how to create a model with pictures, then how to use PathView to show pictures with changes to their size and rotation. The example also contains a “mirrored” part for the pictures giving them even more candy.

Presenter Bio:
Igor Grivko graduated from Moscow State University in 1993, he got his PhD in 1997. He has been working with Qt since 2003. He joined ICS in 2010.