Qt - ArchWiki

# Qt

Related articles

- KDE
- Uniform Look for Qt and GTK Applications
- GTK+

Qt is a cross-platform application and widget toolkit that uses standard C++ but makes extensive use of a special code generator (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Some of its more important features include:

- Running on the major desktop platforms and some of the mobile platforms.
- Extensive internationalization support.
- A complete library that provides SQL database access, XML parsing, thread management, network support, and a unified cross-platform application programming interface (API) for file handling.

The Qt framework is emerging as a major development platform and is the basis of the KDE software community, among other important open source and proprietary applications such as VLC, VirtualBox, Opera, Mathematica, Skype and many others.

## Installation

Two versions of Qt are currently available in the official repositories. They can be installed with the following packages:

- Qt 5.x is available in the qt5-base package, with documentation in the qt5-doc package.
- Qt 4.x is available in the qt4 package, with documentation on AUR in the qt4-doc package.
- Qt 3.x is available from the AUR in the qt3 package, with documentation on AUR in the qt3-doc package.

Warning: Qt packages do not provide the usual bins (e.g. qmake) in `/usr/bin` anymore. Instead `-qt5`, `-qt4` and `-qt3` symlinks are provided (e.g. `qmake-qt5`, `qmake-qt4`, `qmake-qt3`). This may cause compilation failures in Qt3/4 applications. To install usual bins, see #Default Qt Toolkit section.

## Default Qt toolkit

By installing qtchooser you can restore the usual bins (e.g. qmake) in `/usr/bin` and setup the Qt toolkit to use. By default Qt5 is used.

### Using environment variables

To define default Qt toolkit, you can create `QT_SELECT` environment variable. For example, to set Qt4, do `export QT_SELECT=4` in your shell's init file (e.g. `~/.bash_profile.` or `~/.zsh_profile.`).

### Using configuration files

You can set default Qt toolkit by creating a symlink `~/.config/qtchooser/default.conf` to one of .conf files in `/etc/xdg/qtchooser/` directory. For example, to set Qt4 symlink `/etc/xdg/qtchooser/4.conf` to `~/.config/qtchooser/default.conf`:

    $ ln -s /etc/xdg/qtchooser/4.conf ~/.config/qtchooser/default.conf

## Appearance

### Configuration

Qt application will try to mimic the behavior of the desktop environment they are running on, unless they run into some problems or hard-coded settings. For those who still want to change the look and feel of Qt application, the Qt Configuration (qtconfig-qt4 or qt3config) tool is available. QtConfig offers a very simple configuration for the appearance of Qt applications that gives the user easy access to the current Qt Style, colors, fonts and other more advanced options. QtConfig was removed in Qt5. If you want to force Qt5 to use a specific style, set the `QT_STYLE_OVERRIDE` environment variable to your preferred style (e.g. `gtk`).

Although not part of Qt, the KDE System Settings offer many more customization options that are also picked up by Qt applications.

#### Themes

Several styles are already included with Qt, such as a GTK+ style, a Windows style, a CDE style, etc., but others can be installed from the official repositories or the AUR (most are written for KDE Plasma Desktop):

- Oxygen — A desktop theme that comes with the KDE desktop.

  http://www.oxygen-icons.org/ || kdebase-runtime

- QtCurve — A very configurable and popular desktop theme with support for GTK+ and Qt applications.

  http://kde-look.org/content/show.php?content=40492 || qtcurve

- Skulpture — A GUI style addon for KDE and Qt programs that features a classical three dimensional artwork with shadows and smooth gradients to enhance the visual experience.

  http://kde-look.org/content/show.php/?content=59031 || skulpture

- Polymer — A port of the KDE Plastik Style to Qt3.

  http://kde-look.org/content/show.php?content=21748 || polymer

- Bespin — A very configurable KDE theme.

  http://cloudcity.sourceforge.net/frame.php || bespin-svn

#### Fonts

Qt fonts can be configured from QtConfig under Fonts > Default Font.

Note: If you use a GTK+ desktop (such as GNOME or Xfce), and GUI Style is set to Desktop Settings (default) or GTK+, then this setting will be ignored.

#### Icons

There is no way of setting the icon theme from QtConfig, but since Qt follows the Freedesktop.org Icon Specification, any theme set for X is picked up by Qt.

### Manual configuration

Qt keeps all its configuration information in `~/.config/Trolltech.conf`. The file is rather difficult to navigate because it contains a lot of information not related to appearance, but for any changes you can just add to the end of the file and overwrite any previous values (make sure to add your modification under the `[Qt]` header).

For example, to change the theme to QtCurve, add:

    ~/.config/Trolltech.conf

    ...
    [Qt]
    style=QtCurve

### Qt Style Sheets

An interesting way of customizing the look and feel of a Qt application is using Style Sheets, which are just simple CSS files. Using Style Sheets, one can modify the appearance of every widget in the application.

To run an application with a different style just execute:

    $ qt_application --stylesheet style.qss

For more information on Qt Style Sheets see the official documentation or other tutorials. As an example Style Sheet see this Dolphin modification.

### GTK+ and Qt

If you have GTK+ and Qt applications, their looks might not exactly blend in very well. If you wish to make your GTK+ styles match your Qt styles please read Uniform Look for QT and GTK Applications.

## Development

### Supported platforms

Qt supports most platforms that are available today, even some of the more obscure ones, with more ports appearing every once in a while. For a more complete list see the Qt Wikipedia article.

### Tools

This article or section needs expansion.

Reason: missing references to Qt5 tools (Discuss)

The following are official Qt tools:

- Qt Creator — A cross-platform IDE tailored for Qt that supports all of its features.

  http://qt-project.org/doc/qtcreator/ || qtcreator

- Qt Linguist — A set of tools that speed the translation and internationalization of Qt applications.

  http://qt-project.org/doc/qt-4.8/linguist-manual.html || qt4

- Qt Assistant — A configurable and redistributable documentation reader for Qt qch files.

  http://qt-project.org/doc/qt-4.8/assistant-manual.html || qt4

- Qt Designer — A powerful cross-platform GUI layout and forms builder for Qt widgets.

  http://qt-project.org/doc/qt-4.8/designer-manual.html || qt4

- Qt Quick Designer — A visual editor for QML files which supports WYSIWYG. It allows you to rapidly design and build Qt Quick applications and components from scratch.

  http://qt-project.org/doc/qtcreator-2.8/creator-using-qt-quick-designer.html || qtcreator

- QML Viewer — A tool for loading QML documents that makes it easy to quickly develop and debug QML applications.

  http://qt-project.org/doc/qt-4.8/qmlviewer.html || qt4

- qmake — A tool that helps simplify the build process for development project across different platforms, similar to cmake, but with fewer options and tailored for Qt applications.

  https://qt-project.org/doc/qt-4.8/qmake-manual.html || qt4

- uic — A tool that reads *.ui XML files and generates the corresponding C++ files.

  http://qt-project.org/doc/qt-4.8/uic.html || qt4

- rcc — A tool that is used to embed resources (such as pictures) into a Qt application during the build process. It works by generating a C++ source file containing data specified in a Qt resource (.qrc) file.

  http://qt-project.org/doc/qt-4.8/rcc.html || qt4

- moc — A tool that handles Qt's C++ extensions (the signals and slots mechanism, the run-time type information, and the dynamic property system, etc.).

  http://doc.qt.digia.com/4.7-snapshot/moc.html || qt4

### Bindings

Qt has bindings for all of the more popular languages, for a full list see this list.

The following examples display a small 'Hello world!' message in a window.

#### C++

- Package:
  - qt4 - Version 4.x of the Qt toolkit.
  - qt5-base - Version 5.x of the Qt toolkit.
- Website: http://qt-project.org/
- Build:
  - The Qt4 version: `g++ $(pkg-config --cflags --libs QtGui) -o hello hello.cpp`
  - The Qt5 version: `g++ $(pkg-config --cflags --libs Qt5Widgets) -o hello hello.cpp`
- Run with: `./hello`

    hello.cpp

    #include <QApplication>
    #include <QLabel>

    int main(int argc, char **argv)
    {
        QApplication app(argc, argv);
        QLabel hello("Hello world!");

        hello.show();
        return app.exec();
    }

#### QML

- Package: qt4 or qt5-declarative.
- Website: http://qt-project.org/
- Run with: `qmlviewer-qt4 hello.qml`

    hello.qml

    import QtQuick 1.0

    Rectangle {
        id: page
        width: 400; height: 100
        color: "lightgray"

        Text {
            id: helloText
            text: "Hello world!"
            anchors.horizontalCenter: page.horizontalCenter
            anchors.verticalCenter: page.verticalCenter
            font.pointSize: 24; font.bold: true
        }
    }

Note: For version 5.x of the Qt toolkit, we need to import QtQuick 2.y.

#### Python (PyQt)

- Package:
  - python-pyqt4 - Python 3.x bindings for Qt 4
  - python2-pyqt4 - Python 2.x bindings for Qt 4
  - python-pyqt5 - Python 3.x bindings for Qt 5
  - python2-pyqt5 - Python 2.x bindings for Qt 5

- Website: http://www.riverbankcomputing.co.uk/software/pyqt/intro
- Run with: `python hello-pyqt.py` or `python2 hello-pyqt.py`.

    hello-pyqt.py

    import sys
    from PyQt4 import QtGui

    app = QtGui.QApplication(sys.argv)
    label = QtGui.QLabel("Hello world!")

    label.show()
    sys.exit(app.exec_())

The Qt 5.x version is slighly different:

    hello-pyqt.py

    import sys
    from PyQt5 import QtWidgets

    app = QtWidgets.QApplication(sys.argv)
    label = QtWidgets.QLabel("Hello world!")

    label.show()
    sys.exit(app.exec_())

#### Python (PySide)

- Package:
  - python-pyside - Python 3.x bindings
  - python2-pyside - Python 2.x bindings
- Website: http://www.pyside.org/
- Run with: `python hello-pyside.py` or `python2 hello-pyside.py`

    hello-pyside.py

    import sys
    from PySide.QtCore import *
    from PySide.QtGui import *

    app = QApplication(sys.argv)
    label = QLabel("Hello world!")

    label.show()
    sys.exit(app.exec_())

#### C#

- Package: kdebindings-qyoto
- Website: http://techbase.kde.org/Development/Languages/Qyoto
- Build with: `mcs -pkg:qyoto hello.cs`
- Run with: `mono hello.exe`

    hello.cs

    using System;
    using Qyoto;

    public class Hello {
        public static int Main(String[] args) {
            new QApplication(args);
            new QLabel("Hello world!").Show();

            return QApplication.Exec();
        }
    }

#### Ruby

- Package: kdebindings-qtruby
- Website: http://rubyforge.org/projects/korundum/
- Run with: `ruby hello.rb`

    hello.rb

    require 'Qt4'

    app = Qt::Application.new(ARGV)
    hello = Qt::Label.new('Hello World!')

    hello.show
    app.exec

#### Java

- Package: qtjambi or qtjambi-beta.
- Website: http://qt-jambi.org/
- Build with: `javac Hello.java -cp /opt/qtjambi-beta/qtjambi-linux64-community-4.7.0/qtjambi-4.7.0.jar`.
- Run with: `java -cp /opt/qtjambi-beta/qtjambi-linux64-community-4.7.0/qtjambi-4.7.0.jar:. Hello`.

    Hello.java

    import com.trolltech.qt.gui.*;

    public class Hello
    {
        public static void main(String args[])
        {
            QApplication.initialize(args);
            QLabel hello = new QLabel("Hello World!");

            hello.show();
            QApplication.exec();
        }
    }

Note: The build instructions and example have been tested on the beta version of Qt Jambi 4.7.0.

#### Perl

- Package: kdebindings-perlqt
- Website: http://code.google.com/p/perlqt4/
- Run with: `perl hello.pl`

    hello.pl

    use QtGui4;

    my $a = Qt::Application(\@ARGV);
    my $hello = Qt::Label("Hello World!", undef);

    $hello->show;
    exit $a->exec;

#### Lua

- Package: libqtlua
- Website: http://www.nongnu.org/libqtlua/
- Run with: `qtlua hello.lua`

    hello.lua

    label = qt.new_widget("QLabel")

    label:setText("Hello World!")
    label:show()

Note: QtLua is not designed to develop an application in pure Lua but rather to extend a Qt C++ application using Lua as scripting language.

## Resources

- Official Website
- Qt Project
- Qt Documentation
- Planet Qt
- Qt Applications

Category:

- Widget Toolkits