See also

• ClangCodeModel plugin has class CXPrettyPrinter that prints clang-c types in JSON-like format. Use it to debug and feel free to improve this class.
• Clang hacking notes

Clang bugs with known workarounds

• Sometimes diagnostic message have one empty SourceRange, which breaks SourceLocation-based euristic. Example:
  
  1. #include <vector>
  2.  
  3. int main()
  4. {
  5.     std::vector<> a;
  6.     return 0;
  7. }
  
  CXPrettyPrinter reports:
  
  1. CXDiagnostic: {
  2.     'error: too few template arguments for class template 'vector''
  3.     severity: Error
  4.     location: {
  5.         file: '/home/sergey/Документы/wip-clang/test_projects/objc_test/main.cpp',
  6.         line: 5,
  7.         column: 10
  8.     }
  9.     category: 'Semantic Issue';
  10.     ranges: [
  11.         {
  12.             file: '',
  13.             from: {0, 0},to: {0, 0}
  14.         }
  15.     ]
  16.     children: [
  17.         {
  18.             'note: template is declared here'
  19.             severity: Note
  20.             location: {
  21.                 file: '/usr/include/c++/4.6/bits/stl_vector.h',
  22.                 line: 180,
  23.                 column: 11
  24.             }
  25.             category: 'Semantic Issue';
  26.             ranges: [
  27.                 {
  28.                     file: '/usr/include/c++/4.6/bits/stl_vector.h',
  29.                     from: {179, 3},to: {179, 65}
  30.                 }
  31.             ]
  32.         }
  33.     ]
  34. }

Clang bugs

Links to reported bugs will be attached in future

• inside lambda, clang doesn’t include mutable (non-const) methods of current class even if ‘this’ was captured by lambda
  Bug: http://llvm.org/bugs/show_bug.cgi?id=15085
  See example, completion requested in point marked with ‘#’ sign

• Clang does not add virtual functions to proposals list
  
  1. class Base
  2. {
  3. public:
  4.     virtual void overrideMe(int a);
  5. };
  6.  
  7. class Derived : public Base
  8. {
  9. public:
  10.     void #
  11. };

• no way to differ method definition and call with qualifier: completion strings and contexts are the same in both cases: http://llvm.org/bugs/show_bug.cgi?id=15745
  
  1. class Foo
  2. {
  3. public:
  4.     void declarable(int a, float b);
  5. };
  6.  
  7. void Foo::declarable(int a, float b)
  8. {
  9.     if (a != 1)
  10.         Foo::declarable(1, 2.0);
  11. }

Poor diagnostic for such code if C++11 disabled

• clang does not add classes to completion proposals when completing ‘foreach’

• when declaring variable, variable itself proposed with highest priority. It’s error.

• Macro completions not added after class keyword
  
  1. class CLANG_EXPORT CodeCompletionResult
  2. {
  3. };

• Wrong completions inside function-try-block in constructor: http://llvm.org/bugs/show_bug.cgi?id=15660
  
  1. class Class
  2. {
  3.     int a;
  4.     int *c;
  5. public:
  6.     Class(int b) try : a(b), c(new int)
  7.     {
  8.     }
  9.     catch (...)
  10.     {
  11.         // no "delete" proposed
  12.     }
  13. };

• Completion with nested names lookup not performed for comparison with enum value
  
  1.     if (lexer.tokenKind() == Token::LeftBrace) {
  2.     }

• Value types completions added where thay shouldn’t be
  
  1. QStringList createClangOptions(CPlusPlus::ProjectFile::Kind language,
  2.                                CPlusPlus::ProjectPart::CXXExtensions extensions,
  3.                                CPlusPlus::ProjectPart::,
  4.                                CPlusPlus::ProjectPart::QtVersion qtVersion,
  5.                                const QList<QByteArray> &defines,
  6.                                const QStringList &includePaths,
  7.                                const QStringList &frameworkPaths);

• C++11 ‘override’ pseudo-keyword breaks clang_annotateTokens()
  
  1. bool init() override;

• Poor completion context recognition in template params
  
  1. std::vector<#> myVector;

• Clang doesn’t add Informative completion chunk to macro. It better to add macro definition text to informative.
  
  1. #define MACRO std::min(left, right)
  2.  
  3. // Completion proposal "MACRO" doesn't have chunk of kind Informative with text "std::min(left, right)"

• Macro trick used in GLEW library not handled by completion: http://llvm.org/bugs/show_bug.cgi?id=15631

• Completion results for function with optional arguments does not have default argument value: http://llvm.org/bugs/show_bug.cgi?id=14477

Qt Essentials Modules

The Qt Essentials modules are mandatory in all platforms. This list is now part of the official Qt documentation. See the All Modules [qt-project.org] page for the list of released Qt Essentials modules.

See also Qt Add ons Modules.

Qt for Tizen: Roadmap

Introduction:

• Qt 5 for Tizen releases contain:
  • repository qtbase-tizen
• Qt Tizen Integration releases will contain:
  • repository tizenbuildtools
  • repository qtquickcontrols-tizen
  • repository qtsensors-tizen
  • repository qtcreator-tizen
  • repository qtwebkit-tizen

• The focus is for Tizen smartphone profile.

• May 20, 2013
  • Qt 5.1 Beta for Tizen
    • Done: Qt 5.1 Alpha working in Tizen 2.1 Emulator
  • Qt Tizen Integration 0.1 Alpha
    • Done: major Qt Quick Controls for Tizen
    • Done: support for Tizen 2.1 Emulator

• June ??, 2013
  • Qt 5.1 ??? for Tizen
    • Planned: Preliminary support for RD-PQ developer device with Tizen 2.1
    • Planned: bug fixes
  • Qt Tizen Integration 0.1 Beta
    • Planned: Preliminary support for RD-PQ developer device with Tizen 2.1
    • Planned: more Qt Quick Controls for Tizen
    • Planned: Support for screen rotation when device orientation changes (emulator and RD-PQ device)
    • Planned: Support for sensors (emulator and RD-PQ device)
    • Planned: Qt Creator integration: Tizen Kit, installation
    • Planned: bug fixes

• ??, 2013
  • Qt 5.1 RC for Tizen
    • Planned: bug fixes
  • Qt Tizen Integration 0.1 RC
    • Planned: bug fixes

• ??, 2013
  • Qt 5.1 for Tizen
    • Planned: bug fixes
  • Qt Tizen Integration 0.1
    • Planned: bug fixes

Qt for Tizen

Pages

• Introduction | Roadmap
• Development: Qt Creator for Tizen Analysis | Qt Quick Controls for Tizen
• Build: Qt 5 for Tizen Emulator
• Related: Build Qt 4.8.1 for Tizen 1.0 Larkspur on Ref.Device 210

Resources

• Source code:
  • Tizen build tools repository [gitorious.org]
  • Qt Quick Controls for Tizen repository [gitorious.org]
• Blog [qtfortizen.blogspot.com], Twitter [twitter.com], Facebook [facebook.com]
• Google+ [plus.google.com], Videos [youtube.com]
• Ticket (bugs, features) system: TODO
• Development mailing list: development@qt-project.org (subscribe [lists.qt-project.org])
• Users mailing list: interest@qt-project.org (subscribe [lists.qt-project.org])
• IRC: #qt-tizen @ irc.freenode.org
  • You can also connect via web browser [webchat.freenode.net]
  • For a full list of IRC channels of interest to Qt developers, see OnlineCommunities.

External links

• https://www.tizen.org
• http://en.wikipedia.org/wiki/Tizen – introduction with history

Tizen is a Linux Foundation Project. Tizen is a registered trademark of The Linux Foundation. Other names and brands may be claimed as the property of others.

It was back in 1996 that Berlin held its first Karneval der Kulturen (Carnival of Cultures). Inspired by London’s and Rio de Janeiro’s famous annual parties, the festival took place over the Whitsun weekend and has been bringing the city’s streets to life in a four-day blaze of colour and music every year since.

These days, more than a million residents and visitors celebrate the free street festival and parade, which features around 5,000 professional and amateur performers of all ages and ethnicities, as well as bands and DJs.

Taking place from 17 to 20 May in the Kreuzberg neighbourhood’s Blücherplatz, the festival consists of four stages, each featuring music from a different part of the world. Head to Latinauta for samba, salsa, Caribbean beats and Latin rock; Bazaár features neo-genres like turkpop and dönerrock; Eurasia covers everything from Balkan to Indian ragas (melodic forms); and Farafina is Afro-focused with bands from Ghana and Senegal. About 400 stands around the square will sell edible treats and handmade art.

The festival peaks on Whitsunday (19 May) with a street parade, which features colourful dance groups from Korea and Japan, trucks blaring music from Brazil and Angola, plus Irish folk, Jamaican dancehall, Caribbean soca and more. The parade starts at Hermannplatz at noon (get there around 11 am to grab a decent spot) and snakes 4km towards Yorkstraße where it ends in the late afternoon.

Of course for many, this is when the real fun begins. As dusk descends on the city, the techno sound systems are wheeled out and the whole district parties on until the early hours.

SOURCE: BBC

Table of Content

• Download Data from URL
  • Important Classes
  • .pro File
  • filedownloader.h
  • filedownloader.cpp
• Usage
  • Load Pixmap from URL

English Български 한국어فارسی

Download Data from URL

The following code snippet demonstrates how to download data as QByteArray [qt-project.org] from URL. The downloaded data can be saved as a file or converted to appropriate object. For example if an image is downloaded it can be converted to QPixmap [qt-project.org] or QImage [qt-project.org] using method loadFromData() [qt-project.org]

Please note that although the name of the class is FileDownloader the downloaded data is not saved on the disk as file!

Important Classes

• QNetworkAccessManager [qt-project.org]
• QNetworkRequest [qt-project.org]
• QNetworkReply [qt-project.org]
• QUrl [qt-project.org]

.pro File

If you are targeting Symbian devices remember to add the capability for network services.

filedownloader.h

filedownloader.cpp

Usage

Load Pixmap from URL

• Declare slot

• Connect signal downloaded() to the slot

• Load QPixmap from the downloaded data

TODO: WebKit? Qt Multimedia?

tl;dr;

Qt 5 on Windows can be configured to use either OpenGL drivers, or DirectX drivers through the ANGLE library. What you want depends on your use case. The Qt project offers binary installers for both variants.

OpenGL

OpenGL (Open Graphics Library) is a wide spread industry standard [opengl.org] for rendering 2D and 3D computer graphics. It’s the de-facto standard for hardware-accelerated graphics operations on Mac OS X, Linux, and most embedded platforms.

OpenGL ES 2.0 (Open Graphics Library for Embedded Systems) is a stripped-down version of OpenGL for use on embedded systems, which is missing some functions.

The Qt Quick 2 stack in Qt 5 is based on OpenGL, and requires OpenGL 3.0 (alternatively OpenGL 2.x with the framebuffer_object extension) or higher or OpenGL ES 2.0. The Qt OpenGL module [qt-project.org] requires OpenGL 1.3 or later.

OpenGL on Windows

Although Microsoft Windows has native support for OpenGL since quite some time, the supported standard version (version 1 without any drivers installed) is too limited for Qt . Newer versions are generally available through custom graphics drivers, but require users to install them. Also, the quality of the OpenGL support by some drivers is lacking.

ANGLE Project

ANGLE (Almost Native Graphics Layer Engine) is an open source project [code.google.com] by Google. Its aim is to map OpenGL ES 2.0 API calls to DirectX 9 API. A regularly updated version of it is part of qtbase [qt.gitorious.org] .

To compile Qt with ANGLE you have to have a Direct X SDK [msdn.microsoft.com] installed. Starting from Windows Kit 8, this is included in the Windows SDK.

If ANGLE is used in your application, you should ship d3dcompiler_XX.dll along with the Qt libraries. The version string of the D3D shader compiler is pulled from the DirectX SDK header, so make sure to get the same version that ANGLE was built with (e.g. _43 or _46). This becomes especially important if you configure Qt with -angle-d3d11.

Recommendations

• Use Desktop OpenGL if
  • Your application uses OpenGL calls not part of OpenGL ES 2.0
  • Your application does not use OpenGL at all (since ANGLE implies additional deployment dependencies which are then not needed).
  • Your application needs to run on Windows XP. Although it is tempting to use ANGLE as a replacement for missing graphics drivers on this platform, it does not fully work and may lead to crashes, for example, when the security dialog is opened.

• Use ANGLE if
  • You only need OpenGL ES features
  • You have a heterogeneous user base with different Windows versions & graphics cards
  • You do not want your user to have to install a recent graphics card driver

Further Reading

http://qt-project.org/doc/qt-5.0/qtdoc/requirements-win.html
http://qt-project.org/doc/qt-5.0/qtopengl/qtopengl-index.html
http://blog.qt.digia.com/blog/2012/10/24/graphics-on-windows-from-a-different-angle/
http://blogs.msdn.com/b/chuckw/archive/2012/05/07/hlsl-fxc-and-d3dcompile.aspx

LinuxTag 2013

Where? Messe Berlin (Berlin Fairground)
When? 22-25.05.2013

The Plan

• no plan

Booth

We will have a table inside the KDE project booth in Hall 7.1c at booth 150.

Location: OSM [openstreetmap.org], Nokia [here.com]

Wanted!!

• Showcases: If you have an interesting show case that you want to show, please add it to the showcases section.
• Booth staffers: If you want to man the booth, please enter your name in the below schedule table. We should have at least two people there at all times.
• Lightning talks: This is your chance to present an interesting topic to the audience on the booth. If you want to give a lightning talk (5-10 minutes), please add yourself. We will scatter the talks throughout the entire time. You can give time preferences. We might even record the talks. Suggested topics:
  • New features in Qt 5.1
  • Playground projects
  • Qt tools (Creator, etc.)
  • Community

Talks

• none

Booth staff

Available persons

• Niels Weber
• Oswald Buddenhagen
• Tobias Hunger
• Aurindam Jana
• Robert Löhning

Booth duty

• Delivery+Booth setup (Tue, 17h): Ossi?
• Setup (Wed, 8h): People who volunteer for the first shift on Wednesday should help with setup. Additional people please add your name here:
• Teardown (Sat, 16h): People who volunteer for the last shift on Saturday should help with the tear down. Additional people please add your names here:

Check List for booth equipment

NOTE: this may be outdated in parts

• Two high chairs (see Furniture Request [wiki.linuxtag.org])
• Laptops (1)
• Roll ups
• Actual Leaflets
• Plasma/LCD-TV (long HDMI cable!)
• 5 port switch, (Router?)
• Cables (1×10m, 3×5m, 10×2m) (KDE?)
• 2 Power Distributors, Power Chords (one 5m) (KDE?)
• 2-3x USB A -> Micro B cables
• Raspberry Pi
• Micro-SD Cards
• Monitor with SD-Card-Reader or SD-Card USB Adapters
• Duct-Tape (white, black, grey)
• Scissors, Knife, Screwdrivers
• Snacks & Drinks for staffers

Todo

• Organize more show cases
• Organize Demo Image for R-Pi
• Create & Print leaflets
• Create T-Shirts for staffers?
• Create & sell Qt T-Shirts for visitors? Ask Claudia for past experiences.
• Sync with KDE about sharing of power cables/distributors and networking cables.

Compiling ICU with MinGW

Qt 5 / QtWebkit requires ICU, which MinGW distributions do not ship.

Pre-built packages

The ICU Project site [site.icu-project.org] provides pre-compiled libraries for both 32 and 64 bit. However, these depend on the Microsoft Visual C++ 2010 runtime being installed.

Compiling on your own

Requirements

• MSYS command prompt (an sh shell + some UNIX tools, get it from http://sourceforge.net/projects/mingw/files/MSYS/Base/msys-core/msys-1.0.11/MSYS-1.0.11.exe/download?use_mirror=garr. It’s also an (optional) part of mingw.org installer.)
• Working MinGW, or MinGW-w64 toolchain

How to build

• Download latest ICU4C source code from http://site.icu-project.org/download (e.g. icu4c-51_1-src.zip), unzip
• Start a MSYS command prompt (C:\msys\1.0\msys.bat)

Check that gcc is in PATH, otherwise add it, e.g.

Run configure && build:

Finally, run make && make install

ICU 4.9 patch for 64 bit

• For ICU 4.9 / MinGW-w64, you might have to add a patch from trunk: Download http://www.icu-project.org/trac/changeset/31770/icu/trunk/source/tools/toolutil/pkg_genc.c?format=diff&new=31770

Apply with:

Using it

Add the include, lib folders to your compilation environment, e.g. for cmd.exe :

When you now run Qt’s configure.exe ICU should be detected, and Qt links against the libraries.

Compiling ICU with MSVC (Microsoft Visual Studio)

Qt 5 / QtWebkit requires ICU.

Pre-built packages

The ICU Project site [site.icu-project.org] provides pre-built packages for MSVC 2010 , but you have to compile your own version if you’re using another Visual Studio version, or want to taylor the ICU configuration.

Compiling on your own

Requirements

• MSVC toolchain
• Cygwin

How to build

• Download latest ICU4C source code from http://site.icu-project.org/download (e.g. icu4c-51_1-src.zip), unzip

• Put Cygwin in PATH, convert line endings
  
  1. C:\icu\source> set PATH=C:\cygwin\bin;%PATH%
  2. C:\icu\source> dos2unix *
  3. C:\icu\source> dos2unix -f configure

Check whether you have e.g. the MSVC compiler (cl.exe) in PATH. If not, set it up by calling e.g.

Run configure && build:

Finally, run make && make install

Usage

Add the include, lib folders to your compilation environment, e.g. for cmd.exe :

When you now run Qt’s configure.exe ICU should be detected, and Qt links against the libraries.

Table of Content

• How to setup Qt5 for Ubuntu using Virtual Box
  • Introduction
  • Versions
  • 1. Setting Up VirtualBox with Ubuntu
  • 2. Installing Qt 5.0.2 on Ubuntu
  • 3. RabbitVCS (a TortoiseSVN substitute for Ubuntu)
  • 4. Trouble Shooting
  • 5. Final Note
  • 6. Related Articles

How to setup Qt5 for Ubuntu using Virtual Box

Introduction

Having struggled for a few days getting the correct sequence of events to occur to allow me to run Qt on a Ubuntu virtual machine on my window PC I feel I should share what I have found incase others want to do the same.

Why would you want to even do that? – well, in my case, I can now run my Qt project on Windows and Linux very easily and very quickly test it works for both. This provides quicker multi-platform testing. You can also test multiple versions of Ubuntu (or windows) and with different compiler versions as well, you just add more virtual machines.

Finally to be able to work / sync to the same code-base you can install/use rabbitVCS on Ubuntu so that it works in the same way as tortoise SVN in windows, and then all of your virtual machines are “talking” to the same SVN repo… nice :)

Versions

These are the versions that I have used / tested this all with
Windows: XP SP3 (as my host operating system)
Ubuntu: 10.04, 12.04 and 12.10
VirtualBox: v4.2.12

1. Setting Up VirtualBox with Ubuntu

In the purpose of this wiki I will use the example of Ubuntu 12.04 and make notes where other versions may differ.

Install and setup a virtual machine for Ubuntu:

• Download and install VirtualBox latest version
• Run virtual box and cklick “new”
• Enter name and ensure “version” is Ubuntu. Go through the screens and select the following options:
• at least 512MB (more if you can, allow about 1/4 of your memory).
• Create virtual HDD
• VDI
• Dynamic or Fixed (I chose fixed because I heard there can be issues with running out of disk space with dynamic, but I am sure dynamic is probably ok!)
• Allow at Enough space, the default is ok (8GB)…

Now your Virtual Machine is created. Do the following to install Ubuntu:

• Download Linux .iso image from http://releases.ubuntu.com/precise/ (I put it on a USB stick)
• Double click your fresh virtual machine called <name> (whatever you called it)
• It will ask you to select a Startup disk. Click the browse button and select your .iso image. Now your ubuntu will boot from this image
• Ubuntu will run, you will have two options: “Use Ubuntu” or “Install”, click install and follow the installation process, I just used all the defaults (except for username, passwords, etc…).
• Once this is completed you will reboot Ubuntu. If your virtual machine does not automatically restart, close it (shutdown) and re-start it in VirtualBox.
• At this point your Ubuntu may boot and tell you that you are in “low graphics mode”. Don’t panic, just press ctrl+alt+f1 (left ctrl button) to go to the command line and continue with the following steps, otherwise you are done for this part :)
• Login by entering your user name followed by your password.
• Once you are logged in enter: “sudo apt-get update”
• For “sudo” it will ask you for your password again, enter it.
• Enter “sudo apt-get upgrade” to perform the upgrades.
• Now enter “sudo reboot” to reboot, this should sort it.

Once you are in to ubuntu, you may want to install further updates from the update manager… or go into a terminal and run the previous 4 steps (except for the reboot part :o )

Now to make your Virtual Ubuntu experience even better (otherwise you are limited to a tiny window and have no copy/paste buffer or other shared resources, etc…

• You need to install Guest Additions in your Virtual Machine. For Ubuntu there is a handy “install guest addtions” under the devices menu when you are running Ubuntu. Click this.
• This copies some files to: /media/VBOXADDITIONS….
• cd to this location
• now run the linux additions: “./VBoxLinuxAdditions.run”
• Once this is finished, restart your VMachine.

2. Installing Qt 5.0.2 on Ubuntu

Note: For the latest GNU compiler its probably worth getting the latest Ubuntu release (i.e. >= 12.10 for gcc/g++ 4.7 or higher for the c++11 features) rather then trying to upgrade the compiler and all the links/libraries yourself! I recommend Ubuntu 12.10 for the moment which give gnu 4.7.2, but this is all your choice…

• download the latest (or whichever version you want) Qt sdk from qt-project.org/downloads (5.0.2 was used at the time of writing)
• cd to the download directory and enter the following commands:
• sudo chmod +x qt-linux-opensource-5.0.2-x86-offline.run (where this is the file you downloaded, this makes it eXecutable)
• sudo ./qt-linux-opensource-5.0.2-x86-offline.run (to run it)
• Follow the install instructions.

Now you have Qt 5.0.2, with Qt creator and all the tools to run and build your project. But since I documented RabbitVCS I may as well add that next…

3. RabbitVCS (a TortoiseSVN substitute for Ubuntu)

• Enter the following in a terminal (enter password for first “sudo” command
• sudo add-apt-repository ppa:rabbitvcs/ppa
• sudo apt-get update
• For Ubuntu >= 11.10: “sudo apt-get install rabbitvcs-thunar rabbitvcs-gedit rabbitvcs-cli rabbitvcs-nautilus3”
• For Ubuntu < 11.10: “sudo apt-get install rabbitvcs-thunar rabbitvcs-gedit rabbitvcs-cli rabbitvcs-nautilus”
• Now log out of Ubuntu and log back in for changes to take effect.

Note: To use, right click in any folder and do SVN —> Checkout…. the rest is pretty much the same as tortoiseSVN :)
Or, you can use the command line :(

4. Trouble Shooting

This is a list of issues that I faced and how they where resolved, I will add to this list if I find more…

Ubuntu 12.04 has experienced an internal error with /usr/bin/Xorg

Do the following:

• sudo service lightdm stop
• sudo dpkg-reconfigure xorg xserver-xorg xserver-xorg-core
• sudo service lightdm start

“/usr/bin/ld: cannot find -lgcc_s” when building your Qt project

In some later versions of Ubuntu some files seem to have moved or been renamed and we need to make a sym link to fix this (well, this is the easiest way to do it). Do this with the following line in a terminal:

• sudo ln -s /lib/libgcc_s.so.1 /lib/libgcc_s.so

5. Final Note

Feel free to comment, add-to or correct this page :) … or even just laugh and say “look at this idiot there” :o

6. Related Articles

• Install Qt 5 on Ubuntu [qt-project.org]

• Maintainer: Nicolas Arnaud-Cormos (narnaud)
• Developer: Jesper K. Pedersen (blackie)
• Repository: [https://codereview.qt-project.org/#q,status:open+project:playground/qt-creator/plugin-scripting,n,z]

Installation

The plugin is currently in playground/qt-creator/plugin-scripting on qt-project. To get a copy of the sources:

To compile the plugin, you need to setup 2 environment variables: QTC_SOURCE and QTC_BUILD (source and build directory of Qt Creator).
The plugin will be compiled in the local data directory of Qt Creator.

You are free to contribute to this plugin, contribution follow the same workflow as Qt and Qt Creator.

Usage

Global/Local scripts

The plugin supports 2 type of scripts:

• global scripts are available in all projects, and stored in the local data for Qt Creator
• local scripts are only for one project, and stored in the qtc-scripts directory at the root directory of your project.

Scripts

The scripts are stored in one of the directory, the extension is .qs.

To do anything, you need to use the exported objects in javascript, for example:

Status

Scripting plugin itself:

• Locator: done
• Shortcuts: done
• Global/local scripts: done
• Create new script wizard: todo
• Script completion: todo
• Script debugger: todo

Script interfaces:

• logging (debug, error): done
• current editor: done
• text editor support (search, replace, edit): 75%
• C++ editor support: in progress
• QML editor support: todo
• project list: todo
• files in project list: todo
• actions support: todo
• build issues pane: todo

• refactoring: todo
• AST access an manipulation: todo
• add/remove files to project: todo

Table of Content

• Introduction to Gerrit
  • Overview
  • Contribution creation and uploading
  • Requesting and receiving contribution feedback

Introduction to Gerrit

Overview

Main features

Gerrit is a web-based tool that is used for code review. Its main features are the side-by-side difference viewing and inline commenting which makes code reviews quick and simple task. It is used together with Git version control system. Gerrit allows authorized contributors to submit changes to Git repository, after reviews are done. Contributors can get their code reviewed with a little effort, and get their changes quickly through the system.

Gerrit usage

There are two purposes Gerrit usage. First, the contributor can upload changes to Gerrit, and second, approvers and peer reviewers can complete a review process with the web browser. Changes are uploaded with git push command. Any Git client can be used to access Gerrit. The review process includes the following steps:

• Review changes
• Publish comments
• Approve or abandon changes

Gerrit can manage multiple repositories (projects). Branches are fully supported by Gerrit, each repository can have any number of branches.

Gerrit stores changes, which are normal commits, as references in path refs/changes. When contributor pushes changes, a special reference in path refs/for/ is used. For example, when contributor uploads a commit to ‘stable’ branch the target ref will be refs/for/stable.

Git repositories that Gerrit operates on are accessed through Gerrit instead of git-daemon. Any other Git-related service can be used with Gerrit. However, it is recommended that all Git commands are run through Gerrit.

Terminology for Gerrit

Common terms used in Gerrit:

Contribution creation and uploading

Git and Gerrit commands

All Gerrit commands are using SSH protocol and the host port is 29418. A user can access Gerrit’s Git repositories with SSH or HTTP protocols. The user must have registered in Gerrit and a public SSH key before any command line commands can be used.
Before proceeding user needs to have a SSH public key configured in Gerrit.

Creating a new contribution

All contributions will be uploaded with regular Git command, like before. Gerrit handles reviews in commit level. A single contribution can easily result in several reviewable changes in Gerrit. User, typically a contributor, prepares a contribution by following these steps:

1. Cloning from the repository
2. Setting up a commit message hook
3. Creating a topic branch
4. Doing changes
5. Updating repository
6. Pushing changes

See the step-by-step introductions below on how to complete a commit upload. Note that Gerrit SSH service is running in port 29418. There is no need to write this port number every time, just add the following lines to ~/.ssh/config file:

Cloning from repository

The Qt Base Git repository can be cloned from Gerrit over SSH with the following commands:

Note that the Qt Base repository only contains a limited part of Qt, including e.g. Qt Core, Qt GUI, Qt Network, but not Qt Webkit, Qt Script and others. If you want to clone everything, e.g. for building Qt Creator later, use

Setting up commit message hook

To add a Change-Id footer to your commit messages, download a message hook from Gerrit with the following command.

or (if you’re behind a firewall and want to use the https protocol):

Creating a topic branch

Keep code organized in topic branches. [git-scm.com] This is what Git excels in. “next-big-thing” is used as an example topic branch below:

Doing changes

Use your favorite editor to complete a coding task.

Updating repository

Call git add to all files that should be included in the commit that is created, and finally call git commit to create a new commit as follows:

At this point you will enter your commit message into the editor. The first line should be short and to the point, beginning with a verb like “Fix”, “Optimize”, “Add”, etc. The second line must be blank. Following that should be a longer explanation of the change, yet still kept to the point.

A line in the form: “Task-number: QTBUG-01234” may be added to associate the commit with a bug report.

Save and quit the editor.

After the first commit has been performed, if the commit-msg hook is set up properly, then an additional line in the form of “Change-Id: …” should have been added.

To revise the latest commit message use “git commit —amend”.

Pushing changes

Changes are pushed to Gerrit with Git push. Note that special target ref is used.
Gerrit reports how many changes were created and provides links to these changes.

When pushing to Gerrit, a typical refspec [git-scm.com] uses HEAD as source ref and special Gerrit ref for target branch. Target ref is in format refs/for/<branch name>. Pushes to this target ref causes Gerrit to create new changes for all commits pushed in this way. To group your changes push to a topic by using the format refs/for/<branch name>/<topic name>.
Note, that it is possible to use any other ref as source ref instead of HEAD when necessary.

Requesting and receiving contribution feedback

Requesting contribution feedback

Contributor requests feedback by adding reviewers to the change. Typically this is done through web browser. Approver or another contributor who is doing peer-review can review any change without being added as a reviewer when having review access right to the project.

Access the change with web browser and use “Add Reviewer” button to add any other registered user to the review like in the picture below:

Alternatively, reviewers can be added already when uploading a contribution. When pushing a change, reviewers can be identified using receive-pack option. See example below and refer Gerrit user’s guide for more detailed instructions. [gerrit.googlecode.com] Using cc option for receive-pack sends an e-mail notification to that user. Gerrit will avoid sending duplicate emails to the same user.

Reading contribution feedback

It is easy to have an overview of contributions in My Changes page. Contributor can view feedback on his or her contributions by accessing the change page and reading comments file-by-file. It is possible to reply on comments and have discussion about the code review in-line. Each time in-line comments or a review scor

For general information about Qt 5 for Android, please visit the wiki for that.

Building Qt 5 for Android

These are the current build instructions to get to the point where you can deploy a Qt app to an Android device using Qt Creator.

NOTE: Shadow builds are currently broken.

1. First of all you need an Android SDK. You can get the official SDK from Google. Make sure you install both API levels 10 and 11 by using the android tool in the SDK. Android API level 11 is required to build QtMultimedia.

2. You also need an Android NDK. You can use the official NDK from Google, but for full support of all debugging features, please use the customly built NDK at the following location: http://code.google.com/p/mingw-and-ndk/downloads/list

3. Get the Qt Creator source from the “2.7” branch and build it. The released Qt Creator 2.7.0 will not work, as there are required changes in the unreleased version 2.7.1.

4. Get Qt 5:

• git clone git://gitorious.org/qt/qt5.git qt5

• cd qt5

• perl init-repository

5. Configure Qt and skip unsupported modules:

• ./configure -developer-build -xplatform android-g++ -nomake tests -nomake examples -android-ndk <path/to/ndk> -android-sdk <path/to/sdk> -android-ndk-host <e.g. linux-x86_64> -skip qttranslations -skip qtwebkit -skip qtserialport -skip qtwebkit-examples

6. Build. You need a JDK (version 1.6) and you should have this in your PATH. The $JAVA_HOME environment variable needs to be pointing to its directory (e.g. /usr/lib/jvm/java-6-openjdk-i386). Then you can run:

• make

7. Start the Qt Creator you built earlier.

8. Go into Tools -> Options -> Android and set the right paths to the Android SDK and NDK, etc.

9. Add your newly built Qt version to Options -> Build & Run -> Qt Versions.

10. At this point you should be able to create a project and configure it for the Android kit. In order to test, go into the “Run” settings for your project. Under “Deploy Configuration”, check the “Use Qt libraries from local device” option. Also select the “Deploy local Qt libraries” radio button.

11. Now you should be able to connect a device and hit the “Run” button on your project to run it on the device.

The Transition from Qt 4.x to Qt 5

The transition from Qt 4.x to Qt 5 is not expected to be significant. However, the “modularization” of the Qt code base requires some amount of changes to project configuration, such as use of “headers”, and configuration of project build settings (such as changes to the *.pro files).

Qt Creator (master) is compiled using Qt 4 and Qt 5; you can refer to its sources to get an overview of what is required to port an application and keep the sources backwards compatible to Qt 4.

QtWidgets as a Separate Module

example compile time errors

1. error: QMainWindow: No such file or directory
2. error: QToolButton: No such file or directory
3. error: QWidget: No such file or directory

Solution

Add this in your *.pro file:

Change all instances of

to

The code should work now, though sometimes you may require to be more explicit:

QtWebKitWidgets is also a separate module:

example compile time errors

1. error: invalid use of incomplete type 'class QWebFrame'
2. error: forward declaration of 'class QWebFrame'

Solution

Add this in your *.pro file:

Note: when you have QT += webkitwidgets you don’t need QT += widgets

In addition, replace all instances of

to

You can try this by porting a WYSISWYG html editor [qt.gitorious.org] from Qt 4 to Qt 5.

QPrinter Doesn’t Work

If your code has the following lines:

add the following to your project file:

Again, sometimes it may not work and you would need to be explicit:

toAscii() and fromAscii() Methods are deprecated

Replace all instances of

to

For example, given the Qt 4 code

you would change to

QCoreApplication::UnicodeUTF8 is deprecated

This enum type used to define the 8-bit encoding of character string arguments to translate(). This enum is now obsolete and UTF-8 will be used in all cases. So remove all instances of QCoreApplication::UnicodeUTF8. For example:

to

QWorkspace is deprecated

This class is obsolete and was replaced by the QMdiArea class in Qt 4.3. In Qt 5 QWorkspace has been removed. The new class has a similar API to QWorkspace and porting it only involved changing the names of a few methods, signals, and slots.

replace

with

QDrag Problems

Apps that has drop and drag functionality will need some tweaking. A line such as

in Qt 5 will generate the error

To fix this add among the includes:

Fixing #include<> Headers

A Perl script “fixqt4headers.pl” exists in qtbase/bin/. that should be run on source code using Qt that corrects the #include<> directives for Qt components to also consider the module name.

Plugin loading

The Q_EXPORT_PLUGIN,Q_EXPORT_PLUGIN2 macros have been deprecated in favor of the new Q_PLUGIN_METADATA macro. The advantage of the new system is that it allows Qt to query the metadata for the plugin without actually dlopen’ing it. This greatly improves performance and reliability of the plugin system.

The new Q_PLUGIN_METADATA macro is included next to the Q_OBJECT macro in the QObject derived class that is returned when loading the plugin. It contains the plugins IID and a filename pointing to a json file containing the metadata for the plugin. The json file is compiled into the plugin and does not need to be installed.

An example on how to change your plugins can be found by looking at the patch that changes the Gif image format plugin, see http://qt.gitorious.org/qt/qtbase/commit/963b4c1647299fd023ddbe7c4a25ac404e303c5d .

Recommended Reading

• C++ API Changes [qt-project.org]
• The porting guide [qt-project.org]
• Porting Desktop Applications from Qt 4 to Qt 5 [blog.ics.com]
• Porting from Qt 4 to Qt 5 [kdab.com]
• Automated porting from Qt 4 to Qt 5 [kdab.com]
• Converting a Qt 4 project to Qt 5 – General Advice and Difficulties [codeproject.com]

Status of Qt Base in Qt 5 for Android Project

Port is done with a few minor issues.

- Bearer management: Only basic functionality e.g., connections status (online/offline) and available devices.

Qt Quick Controls (Former Qt Desktop Components)

This project aims to deliver Qt Quick components relevant to desktop developers. This includes things like layouts, menus and styling.

IRC channel: #qt-components on irc.freenode.org

Scope

The project focus is to get the current components set working as well as possible for the Qt 5.1 release.

Source Code Access

Use the “stable” branch and compile against a recent build of Qt 5.1 (qt “stable” branch)

Gitorious mirror: http://qt.gitorious.org/qt/qtquickcontrols

Bug Tracking

Use bugreports.qt-project.org [bugreports.qt-project.org], Project “Qt”, Component “QtQuick: Controls” or “QtQuick: Layouts”.

Filter [bugreports.qt-project.org] for viewing all unresolved bugs.

Installation

The components rely on several C++ plugins in order to integrate with the desktop. To install the
components into your Qt directory, simply enter the root directory and do:

This will compile and copy the plugins and components into your QTDIR/qml folder.
If you are compiling against a system Qt on linux, you might have to do a ‘sudo make install’
in order to install the project.

Usage

The examples should show how you can use the components.

There is a video demonstration available at http://www.youtube.com/watch?v=Y1pqL5bXe0A

If you are using the QtQuick 2.0 wizard in Qt Creator there are two issues you should be aware of: – you cannot have a Window (or ApplicationWindow) as the root item. To do this, you need to change your QtQuickView into a QtQmlEngine since Window is not a QtQuickItem. – You have to change QGuiApplication to a QApplication. This is because the components rely on certain widget-specific classes such as QStyle to do native rendering.

API Development Process Ideas

• Process to happen on mailing list (subscribe here: http://lists.qt-project.org/mailman/listinfo/qt-components ).
• When making API proposal/change always include: API definition and real world example (from a developer standpoint).
• Once decided upon an API proposal/change documentation has to be written right away.
• Enforcing a timeline around API discussion: from start of API definition to decision on it: 1 week.
• Making sure that at least one representant of each interested platform validates the API (if possible).
• Try to follow Qt naming convention if unsure.
• In case of unresolvable conflict of opinions, an appointed maintainer will have the last word.

Blogs entries

http://blog.qt.digia.com/2011/03/10/qml-components-for-desktop/
http://blog.qt.digia.com/2011/05/26/table-view-with-qt-quick/
http://blog.qt.digia.com/2011/08/26/toplevel-windows-and-menus-with-qt-quick/
http://blog.qt.digia.com/2012/06/06/desktop-components-for-qt-5/

Table of Content

• Building Qt 5 for BlackBerry
  • Setting up the environment
  • Getting the source
  • Building

Building Qt 5 for BlackBerry

This page provide instructions how to build Q5 for BlackBerry 10 and the Playbook OS. These instructions are intended for those who are going to contributre to Qt on BlackBerry 10 or like to experiment with Qt5 on BlackBerry 10. Please note that recent Qt5 snapshots are tailored to BlackBerry 10 and might not build or not run well on the PlayBook OS.

If you just plan to use Qt for application development for BlackBerry 10, you should strongly consider using QtCreator 2.7 and Qt 4.8.x provided in the BlackBerry 10 NDK, see this page for more details.

Setting up the environment

See Blackberry for the introduction and further instructions.

Getting the source

The approach we will take is to do an in-source build of the Qt5 repositories that are needed but to install them to a custom directory ($HOME/development/qnx/qt5 in the following example). Please also note that we clone and build modules separately. This is procedure is different with the builds for desktop platforms and allows to include only those modules which are relevant. Please adjust paths to suit your setup as needed.

So create a directory to hold the source code:

The repositories that we need are:

1. qtbase
2. qtjsbackend
3. qtxmlpatterns (optional, provides support for XmlListModel in QtQuick)
4. qtsensors (optional, provides access to the device’s sensors)
5. qtmultimedia (optional, for audio and video playback)
6. qtdeclarative
7. qtgraphicaleffects (optional but nice for QtQuick2 special effects)
8. qt3d (optional, provides 3D scenes using QML)
9. qtscript (optional, only needed when using the qtquick1 module)

Building

The process of building Qt5 for BlackBerry devices is very similar to building it for any other platform so it is worth having a quick read through the generic instructions for building Qt5 before proceeding.

Be sure that you have configured your environment to use the BlackBerry 10 NDK as described in Blackberry! This especially concerns setting the right values $PATH to pickup tools and cross-compile tool-chain provided in the NDK.

Linux/OS X

First we need to configure Qt.

Add

When compiling for the Playbook, use the following command:

where <N> is the number of parallel make jobs to run. This is often set to <No. of CPU cores + 1>.

Windows

For the Playbook:

If you want to work with HTTPS protocol, add -openssl option. need to check if the same required on Linux

Mac OS X

After this process, you should have a basic Qt5 installation located in $HOME/development/qnx/qt5 or in C:\dev\qt5install, depending of your operating system.

You may now either move onto building your applications or continue here to install some additional modules to gain access to additional features of Qt5.

If you want to build additional modules, make sure to do this in the right order, because some modules depend on each other (qtjsbackend e.g. MUST be built in installed before qtdeclarative).

To build additional modules we need to use the qmake from our new Qt5 installation so we adjust the PATH environment variable accordingly:

Linux/OS X

Windows

Now for each of the additional modules that you wish to build do the following:

Linux/OS X

Windows

The following modules are known to build at the time of writing:

• qtjsbackend (required for qtdeclarative)
• qtxmlpatterns
• qtdeclarative (required for qt3d)
• qtgraphicaleffects
• qt3d
• qtscript (needed for QtQuick1)
• qtquick1
• qtsensors
• qtmultimedia
• qtwebkit, see Building QtWebKit for Blackberry

See also

• Building Qt4 for Blackberry
• Building QtWebKit for Blackberry
• A HelloWorld using the Blackberry NDK CLI tools
• Building_and_Deploying_Qt_Applications_to_the_Playbook
• Deploying_Qt_to_a_central_place_on_Blackberry_devices

Code Reviews

Participating in the Qt project by contributing and reviewing

This Wiki provides information on how to contribute and review code. It also provides directions to the information on Gerrit and Git used for developing Qt.

Overview of the technical landscape

The servers, database, and tools related to the Qt Open Governance code contribution process as well as their interactions are illustrated in the adjacent picture. The process has been designed to provide increased transparency and quick pass-through for code contributions, and its core is the easy-to-use code review tool, Gerrit. The tool is available for everybody, and besides using it for its main purpose of contributors and feedback gathering, it can be utilized for studying the code of the other contributors.

Here’s an overview diagram of the process:

In order to gain access and log in to Gerrit, a contributor needs to have an existing JIRA account. A new account can be obtained from https://bugreports.qt-project.org/.

Gerrit tool is used in the Qt Project for approval of changes and both automated quality checks and human reviews. It is hosted under the codereview.qt-project.org domain. Contributions are sent as patches to Gerrit with the Git push command, with target ref as refs/for/<branch name>. There will be no direct pushing into a branch. Repository can be accessed with SSH on port 29418.

Continuous Integration (CI) system is used for building and testing. CI fetches reviewed changes from Gerrit, runs build & test for the changes and transfers the changes passed further to the public tip. Staging branches are stored in the Git repository of Gerrit.

In addition to Gerrit’s Git repository, the repository is pushed to Gitorious repository on qt.gitorious.org. That repository is read-only.

Using Git

• Git Installation [developer.qt.nokia.com]
• Get the source [developer.qt.nokia.com]
• Developing and maintaining patches on top of Qt with Git

Using Gerrit

• Setting up your Gerrit environment
• Introduction to Gerrit
  • Contribution creation and uploading
  • Requesting and receiving contribution feedback
  • Approving and abandoning
  • Continuous integration and staging
  • Merging feature branches
  • Access rights
  • Providing feedback about the set up
• VIDEO: Contributing and reviewing a change, 3min 15sec [developer.qt.nokia.com]

Troubleshooting

Checklist for contributing

In order to contribute person needs to have:

• JIRA account: can be created from https://bugreports.qt-project.org
• Register to Gerrit using e-mail https://codereview.qt-project.org
• Accept the Contributor License Agreement
  • Individual contributor does that in Gerrit (Settings -> Agreements -> New Contributor Agreement)
  • Corporate contributor needs to fill in CLA for corporate contributor
• If code is contributed user needs to clone the source code (see: Getting the source code)

Troubleshooting Table

A Real World Troubleshooting Example

This is a lightly edited log of troubleshooting an attempt to push a commit to gerrit for Qt 4.8.

The contents of the pastebin were as follows:

Qt for Tizen: Introduction

Goals

• Qt 5 framework port to Tizen
• Bring the full Qt Creator-based developer experience to Tizen application development
• Offer the default Tizen’s look&feel based on Qt Quick 2 for application developers
• Offer sufficient integration with hardware and with system services

The initiative

Qt for Tizen is a purely community-driven, bottom-up initiative. Rules:

• anyone can join
• transparent decision-making based on meritocracy
• only software available under OSI-approved open source licenses is re-used
• willingness to work with upstream projects
• friendly relationships with the Tizen Project aimed at cooperation
• no official affiliation with Tizen Association, Tizen Steering Group or associated companies

In case of success the works shall be continued as an official port within the upstream and the Tizen Project or (some members of Tizen Association).

Contributors are welcome!

Unique values

These are recognized unique values of Qt and thus Qt for Tizen:

• Qt Creator-based SDK running natively on supported platforms (Linux, Windows, Mac OS X)
  • On Linux it is more lightweight and distribution-agnostic, does not require to switch to Ubuntu
  • Contains only open source components (e.g. no closed plugins or dependency on Oracle Java)
  • With open contribution model
• Native support for accessibility features coming from Qt Quick 2
• Access to numerous software talents (over 500k of Qt developers worldwide according to Digia), vital Qt community, source code examples, existing commercial and open source software
• Investment in Qt technology allows for diversification
  • Qt is a base of multiple mobile platforms such as BlackBerry 10, Ubuntu Mobile, SailfishOS, Qt for Android, and the forthcoming Qt for iOs, not to mention many of custom embedded solutions

Assumptions

• Since Qt Tizen Integration utilizes Qt Quick 2, OpenGL 2.1+ support for desktops or Open GL ES 2.0+ for mobile/embedded devices is needed
• Storage requirements: To be defined
• CPU requirements: To be defined

Building Qt/Android on Windows

Tested last time on v5.1.0-alpha1-184-ge9760f1 2013-04-11

—————————— Configuration ——————————

• Install the latest Perl:
  http://strawberryperl.com/
  Select Destination folder (we’ll call this <PERL_ROOT>, and refer similarly to other install locations).

• Install the latest msysgit:
  https://code.google.com/p/msysgit/downloads/list?q=full+installer+official+git
  Select “Run Git from the Windows Command Prompt”
  Select “Checkout as-is, commit Unix-style line endings”

• Install the latest MinGW-w64 from mingwbuilds:
  http://sourceforge.net/projects/mingwbuilds/files/host-windows/releases/4.7.2/32-bit/threads-win32/dwarf/x32-4.7.2-release-win32-dwarf-rev11.7z/download
  extract to <MINGW_ROOT> and add <MINGW_ROOT>\bin to the front of your PATH.

• Overwrite MinGW-w64’s mingw32-make.exe with a fixed one (the next version of mingwbuilds will include this fix):
  http://mingw-and-ndk.googlecode.com/files/mingw32-make-bin-patches.tar.xz
  Unzip mingw32-make.exe from it (using 7zip for example) and overwrite the one in <MINGW_ROOT>\bin\

• Install the latest JDK 7:
  http://www.oracle.com/technetwork/java/javase/downloads/index.html
  Add <JDK_ROOT>\bin to PATH.

• Install the latest Necessitas Android NDK:
  http://mingw-and-ndk.googlecode.com/files/android-ndk-r8e-ma-windows-x86.7z
  Extract to <ANDROID_NDK_ROOT>

• Install the latest Android SDK (tools only):
  http://developer.android.com/sdk/index.html
  Run the SDK and install Platform 10 to <ANDROID_SDK>
  For building QtMultimedia, also install Platform 11.

• Open cmd.exe window and perform some checks:
  Ensure “where gcc.exe” lists <MINGW_ROOT>\bin\gcc.exe first (before <PERL_ROOT>\c\bin\gcc.exe)
  Ensure “where mingw32-make.exe” lists <MINGW_ROOT>\bin\mingw32-make.exe first.
  Ensure “where perl.exe” lists <PERL_ROOT>\perl\bin\perl.exe first.
  Ensure “where javac.exe” lists <JDK_ROOT>\bin first.

—————————— Cloning ——————————

• Make the root folder for the Qt/Android build:
  Make sure there are no spaces in this path and that it doesn’t contain too many characters.
  I went for “C:\work\build”
  
  1. mkdir C:\work\build
  2. cd C:\work\build

• Follow step 4 at http://qt-project.org/wiki/Qt5ForAndroidBuilding

—————————— Build steps ——————————

..where <N> is the number of parallel jobs your system can optimally exploit.

• Follow steps 7..11 at http://qt-project.org/wiki/Qt5ForAndroidBuilding (replacing make with mingw32-make.exe)

—————————— Finally ——————————

I want to enable building Qt/Android from the MSYS shell and if/when this is done I will update this page with the instructions.

Qt for iOS known issues in 5.1

Building

• “QtQuick1 qmlviewer doesn’t build out of the box. Workaround: disable in pro file” https://codereview.qt-project.org/#change,56043

Examples

General

• “QIOSBackingStore needs to have the same size as its window”
• “Failed to make complete framebuffer object 8cd7” https://codereview.qt-project.org/#change,55454
• Quit quits qt event loop but not app (should do nothing?)
• Dialogs resize on show
• Should we have file dialogs at all?
• Slow startup (due to font loading)
• “This plugin does not support propagateSizeHints()”

sharedmemory:

• Crashes: Program received signal SIGSYS, Bad system call. 0×3b23bbe4 in semget ()

openglwindow:

• Doesnt rotate after rotating to landingscape

http:

• Unable to save index.html, permission denied

googlesuggest:

• full screen line edit, no place for suggestions

bearermonitor:

• no configurations, probably missing plugin

network-chat:

• “crash: Program received signal EXC_BAD_ACCESS, Could not access memory.” https://codereview.qt-project.org/#change,55946

textures:

• black content instead of spinning cubes https://codereview.qt-project.org/55064

hellowindow:

• only one out of 4 windows show up
• lots of “QIOSBackingStore needs to have the same size as its window”

paintedwindow:

• “QOpenGLContext::swapBuffers() called with non-exposed window, behavior is undefined”
• ASSERT: “false” in file /Users/torarne/dev/qt/5.0/qtbase/examples/opengl/paintedwindow/paintedwindow.cpp, line 118 https://codereview.qt-project.org/55081

books:

• “This demo needs the SQLITE driver”

drilldown, cachedtable, relationaltablemodel, sqlwidgetmapper, masterdetail, querymodel, tablemodel:

• “QSqlDatabase: QSQLITE driver not loaded”

mandelbrot:

• resizes on startup

knobs, fingerpaint:

• halts when using system gestures

states:

• layout way too big for screen, retina issue?

sub-attaq:

• popup menu shows up in strange locaton and can’t be clicked

screenshot:

• “QPixmap::scaled: Pixmap is a null pixmap”

systray:

• no system tray detected (TODO: use notification center)

classwizard:

• interaction between line edits not ideal, have to tap twice something we have to look at

draggabletext, fridgemagnets, puzzle:

• can’t drag

lighting:

• shadow is clipped

fademessage:

• missing fade button

chip:

• dragging chips confused with selection

elasticnodes:

• very hard to drag nodes
• seem to be missing touch ends sometimes. node will stay locked as if the finger is still pressing the screen.

dragdroprobot:

• can’t drag colors

flowlayout:

• text not inside window and too big
• text does not move properly when window is moved

anchorlayout:

• child graphics-view items completely busted

dockwidgets:

• text becomes gray boxes when dragging container

mainwindow:

• “void QWidgetPrivate::setMask_sys(const QRegion &): Not supported on ios.”

affine, composition, deform:

• drawing artifacts (black boxes) in UI https://codereview.qt-project.org/#change,55192

styles:

• severe drawing artifacts for NorwegianWood (custom) style https://codereview.qt-project.org/#change,55192

Known Issues – Qt 5.1.0 beta1

All platforms

• Check that your system meets Qt’s requirements [qt-project.org].
• QTBUG-31104: Some example applications are broken
• QTBUG-31107: Standalone assistant is missing qtquickcontrols, qtserialport, qtsensors documentation

Linux

• QTBUG-31132: Many keyboard shortcuts in e.g. Qt Creator do not work
  • Workaround: No immediate one. A source code fix is at https://codereview.qt-project.org/#change,56091

Windows

• QTBUG-29974: PostgreSQL plugin is missing on Windows
  • No workaround yet. Work ongoing.

• QTBUG-30212: [MinGW] Application crashes when virtual call invoked on an object which uses both virtual and non-virtual inheritance
  • Workaround: Manually update toolchain to e.g. x32-4.7.2-release-posix-sjlj-rev11.7z [sourceforge.net]

• QWidget::TabletEvent is not working, since 5.0.0.

Mac OS X

• QTBUG-28336: Mac: linker warns about non-existing directories
  • Workaround: Not needed, the produced binaries work.

Android

• QTBUG-30848: Missing dependency on libQt5QuickParticles.so
  • Work-around for apps that use Particles import in QML:
    1. Run app once
    2. Go into “Run” Settings in project, open “Package Configurations” and click on the “Libraries” tab
    3. Tick the Qt5QuickParticles library.

• QTBUG-30861: Missing dependency on libQt5MultimediaQuick_p.so
  • Work-around for apps that use Multimedia import in QML:
    1. Run app once
    2. Go into “Run” Settings in project, open “Package Configurations” and click on the “Libraries” tab
    3. Tick the Qt5MultimediaQuick_p library.

• QTBUG-30553: Mouse cursor visible when running against Ministro
  • Work-around:
    1. Set the environment variable QT_QPA_EGLFS_HIDECURSOR to 1.

iOS

See Qt for iOS known issues [qt-project.org]

PySide Documentation

Welcome to the PySide documentation wiki page.

Getting Started with PySide

• Get PySide
• Setting Up PySide
• Hello World: Your First PySide Application
• Hello World: Your First PySide Application Using QtQuick/QML
• Avoid These Common Pitfalls
• Differences Between PySide and PyQt

API Reference Manuals

• PySide 1.0.7 API [srinikom.github.com]
• PySide 1.1.0 API [deptinfo-ensip.univ-poitiers.fr]

Tutorials and Example Applications

• PySide Tutorials
• PySide Example Applications

Getting Started with QtQuick/QML

• Introduction to the QML language [doc.qt.nokia.com]
• Understanding Signals and Slots in PySide
• PySide QtQuick and QML Tutorials

QtQuick/QML Topics

• PySide and QtQuick/QML Playground
• Declarative examples in git [qt.gitorious.org]
• Auto Generating QObject From Template in PySide
• Connecting QML signals in PySide
• Defining and using constants from PySide in QML
• Filling and reading QML UI forms from Python
• Multi Selection Lists in Python with QML
• Updating QML content from Python threads
• Using Qt Properties in PySide
• Utilizing Qt Quick Colibri in PySide

Getting Started with QtCreator

• How to use Qt Creator to design Graphical Interfaces for PySide

Getting Started with QtWebkit

• Using QtWebKit and QML with PySide

Getting Started with PySide Mobility

• PySide Mobility 0.2.2 Documentation [web.archive.org] (From Internet Archive)
  • The old link appears lost: http://www.pyside.org/docs/pyside-mobility
• PySide Mobility examples in git [qt.gitorious.org]
• Using QtMobility sensors and QML from PySide
• PySide Mobility Source Code Repositories:
  • Gitorious [qt.gitorious.org]
  • GitHub [github.com]

Topics in Writing PySide and Qt Apps

• SuperHybrids part 2, now Qt + PySide [lynxline.com]

Qt4 to Qt5

• Porting from Qt 4 to Qt 5 [kdab.com]

Distribute PySide Applications

• Packaging PySide Applications on Windows

Compiling ICU with MinGW
Compiling ICU with MSVC

Building Qt 5 from Git

Introduction

This article will try to give some hints for checking out the modularized Qt5 from git and getting it built. Please feel free to update this article as things change during development. Raise issues related to the article via: http://qt-project.org/forums/viewthread/7018

System Requirements

You need git (>= 1.6.x) to get the packages.

To properly configure and build Qt 5 from source you also need Perl (>=5.14) and Python (>=2.6.x), as well as a working compiler.

To enable SSL support in Qt, see: http://qt-project.org/doc/qt-5.0/qtnetwork/ssl.html

For more information regarding platform requirements, see: http://qt-project.org/doc/qt-5.0/qtdoc/requirements.html

Linux/X11

Build essentials

Ubuntu/Debian:

Note: Thanks to Gabor Loki, we have a custom PPA with a meta package “sedkit-env-webkit” that installs all required dependencies for the latest Qt/Qt WebKit builds. You can find it here – https://launchpad.net/~u-szeged/+archive/sedkit – or just add the PPA by issuing on the console:

Fedora:

1. su - -c "yum install perl-version"

OpenSUSE:

Libxcb

Libxcb [xcb.freedesktop.org] is now the default window-system backend for platforms based on X11/Xorg, and you should therefore install libxcb and its accompanying packages. Qt5 should build with whatever libxcb version is available in your distro’s packages (but you may optionally wish to use v1.8 or higher to have threaded rendering support). src/plugins/platforms/xcb/README [qt.gitorious.org] lists the required packages.

Ubuntu/Debian:

Fedora up to 16:

1. su - -c "yum install libxcb libxcb-devel xcb-util xcb-util-devel"

Fedora 17+ (xcb-util-renderutil is currently available in updates repository until it goes stable):

1. su - -c "yum --enablerepo=updates install libxcb libxcb-devel xcb-util xcb-util-devel xcb-util-*-devel"

OpenSuSE 12.2

1. sudo zypper in xorg-x11-libxcb-devel xcb-util-devel xcb-util-image-devel xcb-util-keysyms-devel xcb-util-renderutil-devel xcb-util-wm-devel xorg-x11-devel libxkbcommon-devel

ArchLinux:

1. sudo pacman -S --needed libxcb xcb-proto xcb-util xcb-util-image xcb-util-wm

On Chakra Linux, other than packages mentioned for ArchLinux, you need to install package xcb-util-keysyms separately. It’s available from CCR.

Mandriva/ROSA/Unity:

1. urpmi 'pkgconfig(xcb)' 'pkgconfig(xcb-icccm)' 'pkgconfig(xcb-image)' 'pkgconfig(xcb-renderutil)' 'pkgconfig(xcb-keysyms)' 'pkgconfig(xrender)'

OpenGL support

For Qt Quick 2 a graphics driver with native OpenGL 2.0 support is highly recommended.

Accessibility

It is recommended to build with accessibility enabled, install libatspi 2 and libdbus-1 development packages.

Qt WebKit

When you want to compile WebKit, more dependencies need to be satisfied:

Ubuntu/Debian:

Fedora:

1. su - -c "yum install flex bison gperf libicu-devel libxslt-devel ruby"

OpenSUSE:

1. sudo zypper install flex bison gperf libicu-devel ruby

Mandriva/ROSA/Unity:

1. urpmi gperf

Qt Multimedia

You’ll need at least alsa-lib (>= 1.0.15) and gstreamer (>=0.10.24, but <1.0 for now [lists.qt-project.org]) with the base-plugins package.

Mac OS X

Install the latest Xcode from the App Store. Verify that your Xcode install is properly set up for command line use:

This should give you eg:

You can verify that the right Xcode is being used by running:

If this points to /Developer you’re probably using an older Xcode version. Switch to the latest one by running:

Windows

Windows Graphics Drivers

QML2 requires OpenGL 2.1 or higher or Open GL ES 2.0 to work.

In Windows, two options are available:

1. Use the ANGLE-library [code.google.com] to translate OpenGL calls into DirectX (default)
2. Use the native OpenGL driver for your graphics card

A copy of ANGLE is bundled in Qt 5. To use Option 1, you need to install the DirectX SDK [msdn.microsoft.com] (Note: Starting from Windows Kit 8, this is included in the Windows SDK).

To use Option 2, you need to ensure that your graphics card driver supports OpenGL 2.1 or higher (Note: The stock Windows driver only supports OpenGL 1.1, which is insufficient), and pass `-opengl desktop’ to configure.exe.

Supported Compilers on Windows

• Windows SDK 7.1 with Visual Studio 2010 (recommended). As of 16.3.2012, installing the SDK requires installing the following packages in this order (see readme.html provided with the service pack):

1. Install Visual Studio 2010
2. Install Windows SDK 7.1. See also Cannot_Install_Windows_SDK page.
3. Install Visual Studio 2010 SP1
4. Install Visual C++ 2010 SP1 Compiler Update for the Windows SDK 7.1

• Windows SDK 7 with Visual Studio 2008
• Windows Kit 8 with Visual Studio 2012
• MinGW-w64 based compiler with g++ version 4.7 or higher (e.g. MinGW-builds [sourceforge.net], see also MinGw-64-bit [qt-project.org] ).

Windows Build environment

We recommend creating a command prompt that provides the build environment (see the Qt Creator README [qt.gitorious.org] ). In this environment, Python (e.g. Active Python 2.7 later) and Perl (e.g. Active State Perl 5.12 or later) should be in the PATH.
Get Perl from: http://www.activestate.com/activeperl/downloads [activestate.com]
Get Python from: http://www.python.org/download/releases/ [python.org]
Get Ruby from: http://www.rubyinstaller.org/downloads/ [rubyinstaller.org]

Hint: Make sure that Perl is added to the path in front of git since that ships an outdated version (Perl 5.8), which will cause the scripts to fail.

Multicore building: To speed up building when using nmake, the compiler can be instructed to use all available CPU cores in one of the following ways:

• Pass the option -MP to Qt’s configure
• Set the environment variable CL (specifying Visual Studio compiler options) to /MP (On the command line: set CL=/MP)
• Use the tool jom [qt-project.org] instead of nmake. Note however, that it has issues with module interdependencies, which can cause builds to fail.

ICU on Windows

Qt 5 can make use of the ICU [site.icu-project.org] library for UNICODE and Globalization support. This is required for building Qt WebKit. You can use precompiled versions of ICU with a Visual Studio 2010 dependency from the website, or compile ICU on your own .

At compile time, the absolute paths of include and lib folders of the ICU installation must be appended to INCLUDE and LIB environment variables after calling the setup script of the Windows SDK.

At run-time, the ICU DLLs need to be found. This can be achieved by copying the DLLs to the application folder or adding the bin folder of the ICU installation to the PATH environment variable.

Getting the source code

First clone the top-level Qt 5 git repository:

or (if you’re behind a firewall and want to use the https protocol):

Then check out the target branch (see Branch-Guidelines ):

Following the README.git [qt.gitorious.org] – file we initialize the repository using the script init-repository which clones the various sub-modules of Qt 5. Relevant options:

• --no-webkit : Consider skipping qtwebkit by passing this option. This module is quite big, takes a long time to compile and if often a source of compile errors, so it is recommend to only download it if you intend to use it. You can always re-run init-repository later on to add it.
• --http : Pass this option if you’re behind a firewall.
• --codereview-username <Jira/Gerrit username> : If you plan to contribute to Qt, you should specify your codereview username so that the git remotes are properly set up.

Configuring and building

The Qt5 build system should be fairly resilient against any “outside distractions” – it shouldn’t matter whether you have other Qt versions in PATH, and QTDIR is entirely ignored. However, make sure that you have no qmake-specific environment variables like QMAKEPATH or QMAKEFEATURES set, and the qmake -query output does not refer to any other Qt versions ($HOME/.config/Trolltech/QMake.conf should be empty).

Configure the build (from top level dir). Disabling tests and examples will greatly speed up compilation:

For Linux/Mac OS X:

For Windows:

The -developer-build options export more symbols than in a traditional Qt build in order to allow more classes and functions to be unit tested. It also defaults to a ‘debug’ build, and installs the binaries in the current directory, avoiding the need for ‘make install’. ‘-opensource’ sets the license to be LGPL 2.1. The -nomake examples and -nomake tests parameters make sure examples and tests aren’t compiled by default. You can always decide to compile them later by hand.

• Hint1: On Linux you should also pass -no-gtkstyle. This is because on a number of systems (at least SUSE and Gentoo) pkg-config —cflags gtk+-2.0 actually returns paths that include the system Qt 4.x include directories.

• Hint2: You can add -confirm-license to get rid of the question whether you agree to the license.

• Hint3: On Windows, you might not be able to build if sh.exe is in your PATH (for example due to a git or msys installation). Such an error is indicated by qt5-srcqtbasebinqmake.exe: command not found and alike. In this case, make sure that sh.exe is not in your path. You will have to re-configure if your installation is already configured.

Now trigger the build by running:

For Linux / Mac OS X:

For Windows (MSVC), choose one of the following, depending on your setup/environment:

Or only build a specific module, e.g. declarative, and modules it depends on:

Building Qt WebKit

Linux, Mac

The tools bison, flex, gperf and ruby are required for building.

Windows

WebKit.org [trac.webkit.org] has instructions for building WebKit on Windows. ICU [site.icu-project.org] is required for building.

The tools bison, flex and gperf which are required for building are provided for convenience in the folder gnuwin32\bin. If you are using shadow builds, you must add this directory to your PATH, else no special actions need to be done manually in order to use them.

In addition you need to install Ruby [ruby-lang.org]

Installing (Linux / Mac OS X)

• Note: Installation is only needed if you haven’t used the configure options -developer-build or -prefix “PWD/qtbase”. Otherwise you can just use Qt from the build directory.

To install, run

Cleaning

To get a really clean tree use:

since make confclean no longer works from the top-level of the repo.

Getting updates

To update both the qt5.git repo as well as the submodules to the list of revisions that are known to work, run

If you are planning to do nightly builds, consider using the script qt5_tool that lives in qtrepotools/bin. It provides options for updating the repository, cleaning and building. For example, qt5_tool -u -c -b can be used to clean, update and build. qt5_tool -p -c – b would be used to pull all modules to the head of their master branches.

Depending upon what changed in the source since it was last updated you might have to run configure again. To be really sure everything gets built, you can run clean first, then configure and make.

• Hint1: git submodule update does a checkout in submodules, potentially hiding any local commits you’ve done! If the latter happened to you (and you haven’t been working with branches anyhow), git reflog is your friend ….
• Hint2: When creating scripts for updates on Windows, note that git clean often fails if some process locks a file or folder.

Using latest branches in the submodules

By default the checkout will not contain the latest stable/dev branches of each individual submodule repository, but a combination of versions that are known to work together. If you want to get the absolute latest stuff you can do so on a per-module basis, e.g.

or use qt5_tool to update all repositories:

However, there’s a good chance that compilation will fail due to incompatible versions of submodules! You might want to ask other persons actively working on a module how to resolve these incompatibilities.

Issues

Linux

configure fails with “No QPA platform plugin enabled!” (Linux)

You should install the libxcb and it’s accompanying packages, see ‘System Requirements’.

configure fails with errors like “cannot stat file …”

Your perl version is too old, Qt 5 beta1 needs at least 5.14.

qmlscene segfaults “Cannot create platform GL context, none of GLX, EGL, DRI2 is enabled” (Linux)

Try installing the libx11-xcb-dev package:

afterwards you have to re-run configure and force qtbase/src/plugins/platforms/xcb to recompile.

WebKit doesn’t compile, missing ICU

Currently there is no configure time check for ICU, so install it through the package manager through

on Ubuntu/Debian:

on Fedora:

• You can also compile Qt without Qt WebKit by deleting / renaming the qtwebkit, qtwebkit-examples-and-demos directories.
• The —no-webkit option of configure added, see QTBUG-20577 [bugreports.qt-project.org] issue.

Qt D-Bus fails to build due to “inconsistent user-defined literal suffixes”

This occours when you attempt to build Qt 5 with GCC 4.7 while D-Bus < 1.4.20 is present on your system. (For example, the default Fedora 17 installation is prone to this error.) The error message is this:

Note: The error is in the header files of D-Bus itself, and it has been fixed upstream, see https://bugs.freedesktop.org/show_bug.cgi?id=46147
Solution: either upgrade to a newer version of D-Bus or edit that one line of the header file manually.

[…]::isNull is not defined (from qvariant_p.h)

C++11 support is detected while your GCC doesn’t properly support it
Fixed by passing

cc1: fatal error: .pch/release-shared/QtGui: No such file or directory

Currently unresolved bug with the build of assembly files, see discussion at http://comments.gmane.org/gmane.comp.lib.qt.devel/5933
Fixed by passing

ld: hidden symbol `void QQmlThread::postMethodToThread<QQmlDataBlob*, QQmlDataBlob*, QQmlDataLoaderThread>(void (QQmlDataLoaderThread::)(QQmlDataBlob), QQmlDataBlob* const&)’ isn’t defined

Bug with GCC versions < 4.4.x, see bug report at https://bugzilla.redhat.com/show_bug.cgi?id=493929
Fixed by adding

Windows

qdeclarative doesn’t compile because of missing v8.lib (Windows)

Compiling v8 in qtbase requires Python. Make sure you have a python.exe in your %PATH%, go to qtjsbackend, run qmake && nmake.

Debugging OpenGL issues (Windows)

Set the environment variable QT_QPA_VERBOSE=gl:1 and run the application with DebugView [technet.microsoft.com] installed. The log will show the requested vs obtained OpenGL version. If the log tells you that it only has OpenGL 1.1, QML2 will not work. Note that qmlscene will not report errors about unsupported OpenGL versions.

Questions & Comments

Please raise questions & comments about this article in the forum: http://qt-project.org/forums/viewthread/7018

Table of Content

• Linux
• Mac OS X
• Windows

The tools used to detect the libraries an executable or another shared library depends on are highly platform dependend. Find the tools for various systems (and basic usage for some of them) listed below.

Be aware that the tools not necessarily show you all the libraries you need! It’s best to separately check the dependency libraries too.

Watch out for plugins, that might pull in further dependencies!

The wiki page Qt_Library_Cross_Dependencies lists some of the cross dependencies of the Qt libraries.

Linux

Linux uses the “ldd” command to show the libraries that are linked to an executable or another shared library:

ldd prints the path to the library and some address after the =>. “not found” is printed in case the library is missing.

Be aware: The libraries are not sorted by name in the output!

Mac OS X

Use the “otool” command on Mac OS X to show the libraries that are linked to an executable or another shared library:

Be aware: The libraries are not sorted by name in the output!

In case you build universal binaries (one big executable with object code for different architectures like x86, x86_64, ppc) your out put might look like this:

The libraries should be the same for every architecture. You can limit the output for one architecture by adding a “-arch” switch to otool:

Windows

There is no command line tool for printing the dependencies on Windows. Instead the graphical Dependency Walker tool (depends.exe) is used. The tool was included in Visual Studio until Version 8.0 (aka Visual Studio 2005). It is nowadays downloadable from http://www.dependencywalker.com. [dependencywalker.com] It does not require any development environment to be installed and runs on Windows 95, 98, Me, NT, 2000, XP, 2003, Vista, and 7.

Loading an application into the dependency walker will show all the different dlls loaded including their folder. Errors are shown for dlls incompatible or not available. However, this process provides also some wrong indications. The screen shot below shows the output when Qt creator application is loaded. This version of Qt creator has been compiled with MinGW 4.6.2 (32 bit). Unfortunately, Depends.exe indicates missing dlls (such as GPSVC.DLL and IESHIMS.DLL). Apparently the list of missing dlls might grow with time due to updates of Windows. Those dlls are typically not on the system, but they are also not required for proper working of the application. This makes it a bit difficult to find other missing dll which need to be made accessible to the application. This may be achieved either by adding the folder of the dll to the environment path or copying to the application’s folder.

TIP: press F9 to see the full path of the dll

QtSerialPort

Примечание: Эта страница в стадии разработки, требует пересмотра.

Новости

Заполнить

26.02.2013 – Проект перемещен из песочницы в основную ветвь Qt5!

Краткое описание

Модуль QtSerialPort – это дополнение к библиотеке Qt5, которое предоставляет единый интерфейс для работы как аппаратными, так и с виртуальными последовательными портами.

Примечание: Также добавлена поддержка и библиотеки Qt4.

Последовательный интерфейс благодаря своей простоте и надежности до сих пор популярен в промышленности, при разработке встраиваемых устройств, робототехнике и т.п.

Использование модуля QtSerialPort позволяет разработчикам значительно сократить время на реализацию Qt-приложений, требующих доступ к последовательным интерфейсам.

История

Модуль QtSerialPort берет свое начало из библиотеки QSerialDevice [gitorious.org] (ветка 2.0), которая недавно была перемещена в репозиторий на https://codereview.qt-project.org/

Это было сделано в надежде на более открытую и свободную разработку, а также на помощь сообщества, которое заинтересовано в развитии данного модуля.

Функциональность

В настоящее время API модуля содержит два класса SerialPort и SerialPortInfo.

SerialPort

Класс SerialPort является основным классом модуля и предоставляет набор основных методов и свойств для доступа к ресурсам последовательных портов.

Поддерживает следующие операционные системы:

¹ Для OS Symbian разработка модуля приостановлена в связи с отсутствием разработчиков, а также с тем фактом, что Nokia отказалась от этой платформы и не будет включать ее поддержку в Qt5._

SerialPortInfo

Класс SerialPortInfo является вспомогательным. Он позволяет получить информацию о имеющихся в системе последовательных портах.

Поддерживает следующие операционные системы:

² Для OS Symbian разработка модуля приостановлена в связи с отсутствием разработчиков, а также с тем фактом, что Nokia отказалась от этой платформы и не будет включать ее поддержку в Qt5._

Просмотр исходного кода

Недавно запущено публичное зеркало репозитория проекта на Gitorious [qt.gitorious.org]

Теперь каждый желающий может свободно и оперативно через WEB браузер просмотреть последние изменения в исходном коде проекта.

Получение исходного кода

Для пользователей

Для получения текущего снимка исходного кода репозитория в виде архива достаточно из WEB браузера перейти по этой [qt.gitorious.org] ссылке, загрузка начнется автоматически.

Для желающих использовать Git можно выполнить следующую команду:

Для разработчиков

Получить исходный код и внести свой вклад в разработку могут только зарегистрированные в Gerrit разработчики, используя Git (настройка Gerrit [wiki.qt-project.org]).

Получить исходный код можно так:

где username – логин зарегистрированного в Gerrit пользователя

Сборка и установка

Примечание: При сборке лучше использовать “теневую сборку”, когда для результатов сборки используется отдельная директория. Это позволяет оставить директорию с исходными кодами в нетронутом виде, не засоренную продуктами сборки.

Перед сборкой необходимо:

• установить Perl³
• убедиться что корректно настроены переменные окружения:
  • правильно указаны пути к установленной Qt4/Qt5
  • правильно указаны пути к используемым компиляторам
  • правильно указаны пути к Perl³
• предварительно создать директорию для сборки которая находится на том же уровне, что и директория с исходными кодами
  
  1. /
  2. |- /serialport-src
  3. |- /serialport-build

³ Perl необходим только в случае использования Qt5, подробнее см. тут [qt-project.org]. При использовании Qt4 просто пропустите этот пункт.

Ниже приведены рекомендуемые процедуры сборки библиотеки для Qt4/Qt5.

Примечание: В *nix системах для установки возможно потребуются права суперпользователя:

Использование

При использовании библиотеки необходимо ее подключить в *.pro файл пользовательского проекта, это действие для Qt4 и Qt5 немного отличается:

Qt4

Qt5

Подключение заголовочных файлов от QtSerialPort в пользовательский проект для Qt4 и Qt5 одинаковое:

Простой пример

Ниже представлен простейший пример реализации main.cpp:

Генерация документации

Нет необходимости в сборке документации, потому что текущий снимок документации находится тут [doc-snapshot.qt-project.org].

Для желающих принять участие в разработке

Вся разработка ведется через Gerrit [wiki.qt-project.org], поэтому желающие включиться в процесс разработки должны иметь там учетную запись.

Подробнее о процессе регистрации и разработки можно прочитать здесь [wiki.qt-project.org]

Возможные проблемы

Заполнить

Отслеживание ошибок

Используйте bugreports.qt-project.org [bugreports.qt-project.org], проект “Qt Playground Projects”, компонент “qtserialport”.

QtSerialPort

Note: this page is work in progress, needs review.

News

Fill up

02/26/2013 – The project moved from the playground to trunk Qt5!

Brief description

The QtSerialPort module is an add-on for the Qt5 library, providing a single interface for both hardware and virtual serial ports.

Note: Also added support and for library Qt4.

Serial interfaces, due to their simplicity and reliability, are still popular in some industries like the development of embedded systems, robotics, etc.

Using the QtSerialPort module, developers can significantly reduce the time needed to implement Qt applications that require access to a serial interface.

History

QtSerialPort originated from the third-party library QSerialDevice [gitorious.org] (branch 2.0), which was recently moved to a repository on https://codereview.qt-project.org/

This was done to allow more open development, and to gather and coordinate a community that is interested in developing this module.

Functionality

Currently, the module API contains two classes: SerialPort and SerialPortInfo.

SerialPort

SerialPort is the base class of the module and provides a set of basic methods and properties to access resources on serial ports.

Supports the following operating systems:

¹ For OS Symbian development of the module is suspended due to lack of developers, as well as the fact that Nokia has abandoned the platform and will not include support for it in the Qt5.

SerialPortInfo

SerialPortInfo is a helper class. It provides information on the available serial ports on the system.

Supports the following operating systems:

² For OS Symbian development of the module is suspended due to lack of developers, as well as the fact that Nokia has abandoned the platform and will not include support for it in the Qt5.

View the source code

Recently launched a public mirror of repository project at Gitorious [qt.gitorious.org]

Now everyone can freely and quickly through a WEB browser to view the latest changes in the source code of the project.

Getting the source code

For users

To get the current snapshot source code repository as an archive of WEB browser is enough to click on this [qt.gitorious.org] link, the download will start automatically.

For those who want to use Git can run the following command:

For developers

To get the source code and contribute to the development you need to register a Qt developer account and set it up for use with Gerrit and Git (see Setting up Gerrit [wiki.qt-project.org]).

You can then check out the repository using git, like this:

…with your Gerrit user ID in place of <username>.

Building and Installing

Note: At build process a better use of the “shadow build” when the results of building put out to a separate build directory. This allows us to keep the source directory intact, without clogging of products of build.

Before building the need to:

• install Perl³
• ensure that the environment variables are set correctly:
  • correctly specified the path to the installed Qt4/Qt5
  • correctly specified the path to used the compiler
  • correctly specified the path to the Perl³
• create a build directory that is on the same level as the directory with the source code
  
  1. /
  2. |- /serialport-src
  3. |- /serialport-build

³ Perl is required only in the case of Qt5, see here [qt-project.org]. When using Qt4 just skip this point.

The following are recommended procedures for the build of QtSerialPort library on Qt4/Qt5.

Note: in *nix systems may be required for the installation a super user privileges:

Usage

When using the library, must connect it to the *.pro file of custom project, this step for Qt4 and Qt5 slightly different:

Qt4

Qt5

Include the header files of QtSerialPort to the user project is same for Qt4 and Qt5:

Simple example

Below is a simple example of main.cpp:

Note: CONFIG += serialport must be the first or second line in your .pro file.

Documentation generation

There is no need for documentation building, because snapshot of documentation is available here [doc-snapshot.qt-project.org].

For those wishing to contribute to the development

All development is done through Gerrit [wiki.qt-project.org]. Therefore, those wishing to be involved in the development process must have a Qt developer account.

More information about the registration process and development can be found here [wiki.qt-project.org]

Possible problems

Fill up

Bug Tracking

Use bugreports.qt-project.org [bugreports.qt-project.org], Project “Qt Playground Projects”, Component “qtserialport”.

Table of Content

• Sanity Test
  • Build checks
  • General checks
  • Installer checks
  • Uninstaller checks
  • Both source/binary package checks
  • Qt Creator Checks
  • CMake Checks
• Links

Sanity Test

Sanity Test is a part of the releasing cycle. The purpose is to ensure that the Qt SDK is ready for further testing.

Build checks

• Asks about license
• Compiles with minimal options (eg. -opensource -confirm-license)
  Run configure command with the following options
  
  1. configure -developer-build -opensource -nomake examples -nomake tests -confirm-license
• Compiles as static build (where supported)
  Run configure command with ‘-static’:
  
  1. configure -static ...
• Compiles in namespace (where supported)
  Run configure command with ‘-qtnamespace <namespace>’:
  
  1. configure -qtnamespace CustomName ...
• Compiles with shadow build
  Create a new folder. cd to the new folder. Run the configure command from the source directory.
• Compiles cross-compiled
  Use -xplatform parameter, e.g.
  
  1. configure -embedded arm -xplatform qws/linux-arm-g++ ...