Qt Reference Documentation

Motif Extension

AccessibleEventID.idl File Reference

Arora Browser

Netscape Cookie Specification

Sun Studio Patches

DirectFB - IDirectFBImageProvider

Framebuffer HOWTO

qsslkey example

GnuWin32 Project

http://linux.sybase.com

The LLDB Debugger

Direct X SDK

Microsoft Active Accessibility Event Constants

Mitigating Cross-site Scripting With HTTP-only Cookies

New and Modified BSD Licenses

publicsuffix.org

XML Bookmark Exchange Language Resource Page

ICU

TDM-GCC

Trafikanten

WebKit Open Source Project

ActivePerl

Pthreads Programming: A POSIX Standard for Better Multiprocessing

Thread Time: The Multithreaded Programming Guide

Threads Primer: A Guide to Multithreaded Programming

Win32 Multithreaded Programming

CMake Documentation

CMake find_package Documentation

CMake target_link_libraries Documentation

CMake AUTOMOC Documentation

CMake LOCATION Documentation

CMake POSITION_INDEPENDENT_CODE Documentation

C++ Reference - memcpy

Common Unix Printing System (CUPS)

CUPS

Dependency Walker

DirectFB - IDirectFBPalette

DirectFB - IDirectFBSurface

DirectFB - IDirectFBWindow

DirectFB - CreateInputEventBuffer

DirectFB - DFBSurfaceBlittingFlags

DirectFB - DFBSurfaceDescription

DirectFB - df_window example

ECMAScript Language Specification

freedesktop.org

Icon Themes Specification

XEmbed Specification

Desktop Entry Specification

http://www.freetds.org

GNOME

GNU General Public License

GNU Lesser General Public License, version 2.1

GNU Emacs

C++ GUI Programming with Qt 4, 2nd Edition

KDE

The K Desktop Environment

KDE

KDE applications

Khronos OpenGL ES API Registry

libusb

MinGW

OpenGL Registry

OpenSSL Toolkit

"Item View Classes" Chapter of C++ GUI Programming with Qt 4

http://www.postgresql.org

PostgreSQL MinGW/Native Windows

Python

Qt Centre

http://www.sqlite.org

http://www.sybase.com

http://www.unixodbc.org

SVG Working Group

About SVG

Scalable Vector Graphics

SVG 1.2 Tiny Static Features

HTML5 Web Database API

Standard CSS2 selector

SVG color keyword names

Mobile SVG Profiles

SVG 1.2 Tiny

HTML 4

HTML 5

State Chart XML: State Machine Notation for Control Abstraction

error handling in the XQuery language

W3C XML specifications

XML Schema

Statecharts: A visual formalism for complex systems

XaoS

ANGLE

Mac OS X Aqua

JavaScript Resources

About JavaScript

JavaScript Guide

JavaScript Reserved Words

Qt Account Sign-up

Pimp my video

Qt Bug Tracker

Qt Quarterly

Qt Quarterly: Another Look at Events

Qt Quarterly: Plural Form in Translation

Eclipse Plugin

Qt 4.8 Reference Documentation

Qt Quick 1 Reference Documentation

Livecoding video effects with Qt5

Qt Homepage

Downloads

Qt Licensing Overview

Qt for BlackBerry

QtMediaHub

Qt Coding Style

external: Translating Qt Into Other Languages

Qt Multimedia Backends

QtonPi

jom

Public Qt Repository

qtestlib-tools

Qt Creator: Adding Qt Designer Plugins

Qt Creator: Acknowledgements

Qt Creator: Advanced Use

Qt Creator: Analyzing Code

Qt Creator: Detecting Memory Leaks

Qt Creator: Running Autotests

Qt Creator: Beautifying Source Code

Qt Creator: Specifying Dependencies

Qt Creator: Building and Running an Example

Qt Creator: Customizing the Build Process

Qt Creator: Specifying Build Settings

Qt Creator: Building and Running

Qt Creator: Building for Multiple Platforms

Qt Creator: Profiling Function Execution

Qt Creator: Checking Code Syntax

Qt Creator: Parsing C++ Files

Qt Creator: Using Clang Static Analyzer

Qt Creator: Using Command Line Options

Qt Creator: Specifying Code Style Settings

Qt Creator: Working in Edit Mode

Qt Creator: Coding

Qt Creator: Completing Code

Qt Creator: Configuring Projects

Qt Creator: Configuring Qt Creator

Qt Creator: Connecting Mobile Devices

Qt Creator: Analyzing CPU Usage

Qt Creator: Interacting with the Debugger

Qt Creator: Setting Up Debugger

Qt Creator: Launching the Debugger

Qt Creator: Adding Debuggers

Qt Creator: Debugging a C++ Example Application

Qt Creator: Using Debugging Helpers

Qt Creator: Debugging Qt Quick Projects

Qt Creator: Debugging

Qt Creator: Deploying Applications to Android Devices

Qt Creator: Deploying Applications to Embedded Linux Devices

Qt Creator: Deploying Applications to QNX Neutrino Devices

Qt Creator: Deploying to Mobile Devices

Qt Creator: Designing User Interfaces

Qt Creator: Connecting Android Devices

Qt Creator: Connecting Bare Metal Devices

Qt Creator: Connecting Embedded Linux Devices

Qt Creator: Connecting iOS devices

Qt Creator: Connecting QNX Devices

Qt Creator: Connecting Windows Runtime Devices

Qt Creator: Comparing Files

Qt Creator: Pasting and Fetching Code Snippets

Qt Creator: Using External Tools

Qt Creator: Using FakeVim Mode

Qt Creator: Finding and Replacing

Qt Creator: Writing Code

Qt Creator: Searching with the Locator

Qt Creator: Specifying Text Editor Settings

Qt Creator: Configuring the Editor

Qt Creator: Refactoring

Qt Creator: Specifying Editor Settings

Qt Creator: FAQ

Qt Creator: Finding

Qt Creator: Getting Started

Qt Creator: Glossary

Qt Creator: Getting Help

Qt Creator: Using the Help Mode

Qt Creator: Semantic Highlighting

Qt Creator: Indenting Text or Code

Qt Creator: Keyboard Shortcuts

Qt Creator: Known Issues

Qt Creator: Using Text Editing Macros

Qt Creator: Editing MIME Types

Qt Creator: Modeling

Qt Creator: Supported Platforms

Qt Creator: IDE Overview

Qt Creator: Setting Up a CMake Project

Qt Creator: Creating Projects

Qt Creator: Setting Up a Generic Project

Qt Creator: Managing Sessions

Qt Creator: Managing Projects

Qt Creator: Opening Projects

Qt Creator: Using Other Build Systems

Qt Creator: Setting Up a Qbs Project

Qt Creator: Adding Libraries to Projects

Qt Creator: Adding Qt Versions

Qt Creator: Adding JSON-Based Wizards

Qt Creator: Adding XML-Based Wizards

Qt Creator: Adding New Custom Wizards

Qt Creator: Setting Up an Autotools Project

Qt Creator: Debugging a Qt Quick Example Application

Qt Creator: Using QML Modules with Plugins

Qt Creator: Profiling QML Applications

Qt Creator: Using Qt Quick Designer Extensions

Qt Creator: User Interface

Qt Creator: Qt Quick UI Forms

Qt Creator: Specifying Run Settings

Qt Creator: Running on Multiple Platforms

Qt Creator: Running Valgrind Tools Remotely

Qt Creator: Sharing Project Settings

Qt Creator: Adding Kits

Qt Creator: Showing Task List Files in Issues Pane

Qt Creator: Testing

Qt Creator: Tips and Tricks

Qt Creator: Adding Compilers

Qt Creator: Troubleshooting Debugger

Qt Creator: Tutorials

Qt Creator: Optimizing Applications for Mobile Devices

Qt Creator: Developing Widget Based Applications

Qt Creator: Using Qt Quick Designer

Qt Creator: Using Valgrind Code Analysis Tools

Qt Creator: Using Version Control Systems

Qt Creator: Developing Qt Quick Applications

Qt Creator: Creating a Qt Widget Based Application

Qt Creator Manual

Qt Creator: Adding Connections

Qt Creator: Editing PathView Properties

Qt Creator: Using Qt Quick Toolbars

Qt Creator: Creating a Mobile Application

Qt Creator: Creating a Qt Quick Application

Qt Creator: Using Qt Quick UI Forms

Qt Creator: Browsing ISO 7000 Icons

Qt Creator: Creating Buttons

Qt Creator: Creating Components

Qt Creator: Exporting Designs from Graphics Software

Qt Creator: Creating Qt Quick Projects

Qt Creator: Creating Scalable Buttons and Borders

Qt Creator: Creating Screens

Qt Creator: Technical Support

RFC 1179

RFC 1036

RFC 1738

RFC 1928

RFC 1929

RFC 2045

RFC 2109

RFC 2822

RFC 2965

RFC 3174

RFC 3491

RFC 3986

RFC 850

How to Report a Bug

Annotated Class List

All Classes

Class and Function Documentation

Class Lists

Function Lists

All Functions

Inheritance Hierarchy

All Namespaces

Obsolete Classes

C++ classes that are deprecated

C++ classes that contain one or more members that are deprecated

Obsolete QML Types

QML Types with Obsolete Properties or Methods

All QML Basic Types

All QML Types

Qt Configure Options

Source, Build, and Install Directories

Including and Excluding Qt Modules

Excluding a Qt Submodule

Including or Excluding Features

Third-Party Libraries

Compiler Options

Cross-Compilation Options

Specific Options for Platforms

OpenGL Options for Windows

Networking and Connectivity

Network Communication

WebSockets

World Wide Web Support

Inter-Process Communication

Serial Port Communication

Bluetooth Communication

Near Field Communication

Core Internals

Objects, Properties, and Events

Container Classes

Internationalization

Inter-Process Communication

Threading

Platform Support

Data Storage

Saving and Loading Data

SQL Support in Qt

XML Support in Qt

JSON in Qt

Local Storage

QSettings Class

Resources

File Archiving

Deploying Plugins

The Plugin Directory

Loading and Verifying Plugins Dynamically

Debugging Plugins

Deploying an Application on Android

The APK Package

Package Template

AndroidManifest.xml

Java Code

Resources

res/values/libs.xml

res/values/strings.xml

Libraries

Building the Android Application Package

androiddeployqt

Required Steps Before Running androiddeployqt

Command Line Arguments

Dependencies Detection

Android-specific qmake Variables

Deployment in Qt Creator

Deploying Qt Applications

Static vs. Shared Libraries

Deploying Qt's Libraries

Licensing

Platform-Specific Notes

Using qt.conf

Format and Location

Overriding Paths

Configuring Arguments to the Platform Plugins

IDC - The Interface Description Compiler (ActiveQt)

testcon - An ActiveX Test Container (ActiveQt)

CMake Manual

Getting Started

Imported targets

Using Qt 5 with CMake older than 2.8.12

Using Qt 5 with CMake older than 2.8.11

Using Qt 5 with CMake older than 2.8.9

Variable Reference

Module variables

Installation variables

Macro Reference

Qt5Core macros

Qt5Widgets macros

Qt5DBus macros

Qt5LinguistTools macros

Debugging Techniques

Configuring Qt for Debugging

Debugging in macOS and Xcode

Debugging With/Without Frameworks

With Frameworks:

Without Frameworks:

Command Line Options Recognized by Qt

Environment Variables Recognized by Qt

Warning and Debugging Messages

Providing Support for the qDebug() Stream Operator

Debugging Macros

Common Bugs

Using the Meta-Object Compiler (moc)

Usage

Writing Make Rules for Invoking moc

Command-Line Options

Diagnostics

Limitations

Multiple Inheritance Requires QObject to Be First

Function Pointers Cannot Be Signal or Slot Parameters

Enums and Typedefs Must Be Fully Qualified for Signal and Slot Parameters

Nested Classes Cannot Have Signals or Slots

Signal/Slot return types cannot be references

Only Signals and Slots May Appear in the <@keyword>signals</@keyword> and <@keyword>slots</@keyword> Sections of a Class

Resource Compiler (rcc)

User Interface Compiler (uic)

Options

Examples

Development Tools

Qt for Android Examples

Running the Examples

Essentials

Qt Quick and QML Examples for Android

Qt for iOS Examples

Running the Examples

Essentials

Qt Quick Examples for iOS

All Qt Examples

Qt Examples And Tutorials

Running the Examples

Community Examples

All Examples

Android: App Manifest

Qt Charts

Qt Data Visualization

Qt for Device Creation

Qt Purchasing

Qt Quick 2D Renderer

Qt Quick Compiler

Officially Supported Platforms

Qt Virtual Keyboard

Enginio Manual

Qt WebKit

Qt WebKit Widgets

Emulator

Qbs Manual

Qt Wayland Compositor

Building and Running Example

Configuring Qt Creator

Android APK

Creating a Mobile Application

Qt VS Tools

Xcode

New and Modified BSD Licenses

Contributing to Qt

How to compress data with Qt?

Qt Licensing Overview

OpenSSL Configure Options

Building Qt 5 From Git

Qt Add-ons

Building Qt 5 for Android

Bluetooth SIG

The Chromium Projects

GNU Free Documentation License

GNU General Public License (GPL)

GNU Lesser General Public License, version 3

GNU Lesser General Public License, version 2.1

OpenGL glTF

OpenGL Instanced Rendering

OpenGL Primitive Restart

Qt Account

Qt Enterprise

Windows Store: QuickForecast

Qt FTP

Qt HTTP

Xcode5Req

iTunes: Flyingbus

iTunes: Qt Hangman

iTunes: QtQuicksand

iTunes: Quick Forecast

iTunes: SubAttack

Google Play Developer Console

Google Play: Flyingbus

Google Play: Qt 5 Everywhere

Google Play: Introduction to Qt 5

Google Play: Qt Hangman

Google Play: Quick Forecast

Qt Cloud Services

Sailfish OS

BSD 3-clause "New" or "Revised" License

Tizen

macOS

Accessibility for Qt Quick Applications

Introduction

Accessibility for QWidget Applications

Introduction

Accessibility in QWidget based applications

The Accessible Object Tree

The Static QAccessible Functions

Implementing Accessibility

The QAccessibleObject and QAccessibleWidget Convenience Classes

QAccessibleWidget Example

Handling Action Requests from Clients

Implementing Accessible Plugins

Implementing Interface Factories

Accessibility

Introduction

Making Applications Accessible

Desktop Integration

Useful Classes

Opening External Resources

System Tray Icons

Desktop Widgets

Inter-Process Communication in Qt

TCP/IP

Shared Memory

D-Bus protocol

QProcess Class

Session Management

Overview of Qt's Undo Framework

Undo framework

Introduction

Classes

Concepts

Threading Basics

What Are Threads?

GUI Thread and Worker Thread

Simultaneous Access to Data

Using Threads

When to Use Alternatives to Threads

Which Qt Thread Technology Should You Use?

Qt Thread Basics

QObject and Threads

Protecting the Integrity of Data

Dealing with Asynchronous Execution

Examples

Digging Deeper

Thread-Support in Qt Modules

Threads and the SQL Module

Painting in Threads

Threads and Rich Text Processing

Threads and the SVG Module

Threads and Implicitly Shared Classes

Threads and QObjects

QObject Reentrancy

Per-Thread Event Loop

Accessing QObject Subclasses from Other Threads

Signals and Slots Across Threads

Reentrancy and Thread-Safety

Reentrancy

Thread-Safety

Notes on Qt Classes

Synchronizing Threads

Low-Level Synchronization Primitives

Risks

Convenience classes

High-Level Event Queues

Multithreading Technologies in Qt

QThread: Low-Level API with Optional Event Loops

QThreadPool and QRunnable: Reusing Threads

Qt Concurrent: Using a High-level API

WorkerScript: Threading in QML

Choosing an Appropriate Approach

Comparison of Solutions

Example Use Cases

Thread Support in Qt

Topics:

The Threading Classes

Unicode in Qt

Unicode

Qt's Classes for Working with Strings

Information about Unicode on the Web

Unicode in Qt

Why Does Qt Use Moc for Signals and Slots?

Syntax Matters

Code Generators are Good

GUIs are Dynamic

Calling Performance is Not Everything

No Limits

Qt Quick Text Editor - Connecting Actions

Importing the DocumentHandler QML Type

Assigning Actions

Deploying TextEditor

Example Files

Qt Quick Text Editor Guide - Logic

Implementing the Logic and C++ Backend

Creating the Document Handler

Registering the DocumentHandler Class

Using the DocumentHandler QML type

Example Files

Qt Quick Text Editor Guide - UI

Defining the Application Layout

Adding the Controls

Setting Up the Tool Bar

Adding the Tool Buttons

Setting Up the Text Area

Example Files

Qt Quick Text Editor Guide

Application Design

Setting Up the Environment and Project

Project Files

Resource Files

Example Files

ActiveQt Examples

Animation Framework Examples

Drag and Drop Examples

Gestures Examples

Layout Examples

SQL Examples

State Machine Examples

Threading and Concurrent Programming Examples

XML Examples

Getting Started with Qt

Platform Requirements

Explore Qt

Setting Up Projects

Developing with Qt Creator

Reference Documentation

Qt Project Community

Getting Started Programming with Qt Quick

QML to Build User Interfaces

Defining a Button and a Menu

Basic Component - a Button

Creating a Menu Page

Implementing a Menu Bar

Using Data Models and Views

Building a Text Editor

Declaring a TextArea

Combining Components for the Text Editor

Decorating the Text Editor

Implementing a Drawer Interface

Where to Go from Here

Extending QML using Qt C++

Exposing C++ Classes to QML

Building a Qt Plugin

Registering a Class into QML

Creating QML Properties in a C++ Class

Importing a Plugin in QML

Integrating a File Dialog into the File Menu

Final Text Editor Application

Running the Text Editor

Getting Started Programming with Qt Widgets

Creating the Notepad Project

Main Source File

Designing a UI

Using Qt Designer

Notepad Header File

Notepad Source File

Project File

Adding User Interaction

Adding Push Buttons

Adding Menu Items

Opening Files

Saving Files

Building and Running Notepad

Building and Running from the Command Line

Building Qt Sources

General Installation Information

Windows

macOS

Linux/X11

Embedded Linux

Android

iOS

WinRT

Windows CE

OpenSSL (Version 1.0.0 or Later)

Installing Qt for Windows CE

Step 1: Install the License File (Commercial Editions Only)

Step 2: Set the Environment Variables

Step 3: Configure Qt

Step 4: Build Qt Library

Qt Examples

Qt for Windows CE Requirements

Requirements

Known Issues

Graphics

2D Graphics with QPainter

OpenGL and 3D

Qt Quick Scene Graph

Printing

Images

High DPI Displays

High DPI Displays

Issues with High DPI

Qt High DPI Support Overview

Operating System Support

macOS and iOS

Microsoft Windows

Scaling

DPI Awareness

High DPI Support in Qt

Migration of Existing Applications

Glossary Of High DPI Terms

Standard Accelerator Keys

Setting the Application Icon

Setting the Application Icon on Windows

Setting the Application Icon on macOS

Setting the Application Icon on Common Linux Desktops

K Desktop Environment (KDE)

GNOME

Exception Safety

Exception Safe Modules

Containers

Out of Memory Handling

Recovering from Exceptions

Exceptions in Client Code

Signals and Slots

How to Create Qt Plugins

QT_DEBUG_PLUGINS

QT_NO_PLUGIN_CHECK

The High-Level API: Writing Qt Extensions

The Low-Level API: Extending Qt Applications

Locating Plugins

Static Plugins

Details of Linking Static Plugins

Creating Static Plugins

Deploying and Debugging Plugins

Restoring a Window's Geometry

Scalability

Resizing Application Windows Dynamically

Laying Out Screen Controls Dynamically

Using Bindings

Handling Pixel Density

High DPI Scaling on macOS and iOS

Calculating Scaling Ratio

Loading Files Depending on Platform

Loading Components on Demand

Switching Orientation

Session Management

Shutting a Session Down

Protocols and Support on Different Platforms

Getting Session Management to Work with Qt

Testing and Debugging Session Management

Creating Shared Libraries

Using Symbols from Shared Libraries

Header File Considerations

Binary Compatibility

Third Party Libraries

Source Code

Library Files

Destination Directory

Calling Qt Functions From Unix Signal Handlers

Qt 5.6

Qt Reference Documentation

Qt Framework

Qt Creator IDE

Tools and Toolchains

Licenses Used in Qt

Reference

Getting Started

Overviews

Translation Rules for Plurals

Writing Source Code for Translation

Using QString for All User-Visible Text

Using tr() for All Literal Text

Defining a Translation Context

Using tr() to Obtain a Translation

Using tr() to Localize Numbers

Translating Non-Qt Classes

Translator Comments

Adding Meta-Data to Strings

Disambiguation

Handling Plurals

Translating Text That is Outside of a QObject Subclass

Using QCoreApplication::translate()

Using QT_TR_NOOP() and QT_TRANSLATE_NOOP() in C++

Using QKeySequence() for Accelerator Values

Using Numbered Arguments

Further Reading

Third-Party Licenses Used in Qt

EGL 1.5 Headers

forkfd

FreeBSD strtoll and strtoull

Google Type Traits

FreeType 2 (freetype) version 2.3.12

HarfBuzz (harfbuzz)

JasPer (libjasper) version 2.0

JPEG Software (libjpeg) version 8c

Lipi Toolkit (LipiTk)

MD4 (md4.cpp and md4.h)

MD5 (md5.cpp and md5.h)

Mesa 3D Graphics Library

MNG Library (libmng) version 1.0.10

OpenGL ES 2.0 Headers

OpenGL ES 3.1 Headers

OpenKODE Core 1.0 Header

OpenWnn

Pinyin

PNG Reference Library (libpng) version 1.6.17

SHA-1 (sha1.cpp)

SHA-3, originally known as Keccak

SQLite (sqlite) version 3.8.5.0

TIFF Software Distribution (libtiff) version 3.9.2

Three.js Loader

Traditional Chinese IME (tcime)

gl-matrix.js version 2.2.2

Wintab API (wintab)

Data Compression Library (zlib) version 1.2.5

JavaScriptCore

Pixman (pixman) version 0.17.11

WebCore (WebKit)

The Public Suffix List

IAccessible2 IDL Specification

ANGLE (angle)

OpenGL (ES) 2.0

Shift-JIS Text Codec

ISO 2022-JP (JIS) Text Codec

EUC-JP Text Codec

EUC-KR TextCodec

GBK Text Codec

Big5 Text Codec

FFTReal version 2.11

Bison Parser 2.3a

PowerVR

Cycle

TSCII Text Codec

Valgrind:

valgrind.h specific license

Callgrind

callgrind.h specific license

Stack-less Just-In-Time compiler

xcb

Botan version 1.8.8

at-spi and at-spi2

Poly2tri

BlueZ

Easing Equations

xkbcommon

Clucene Core Library

Wayland Protocol

WebP (libwebp) version 0.4.3

JavaScriptCore Macro Assembler

V8 double/string conversion library

Android GNU C++ Run-time Licensing

Information About License From GCC Headers

The GCC Run-time Library Exception

Qt Commercial License

Purchasing and Sales Information

GNU Free Documentation License (FDL)

GNU Lesser General Public License (LGPL)

LGPL version 3

LGPL version 2.1

The Qt Company Qt LGPL Exception version 1.1

Licenses for Fonts Used in Qt for Embedded Linux

Adobe Helvetica

Adobe Utopia

Babelfish

Bigelow & Holmes Luxi

Bitstream Charter and Courier

Bitstream Vera

Cursor

DejaVu Fonts

Fixed Fonts

IBM Courier

Micro

Unifont

Other Licenses Used in Qt

Native Style for Android

QSegfaultHandler Class

Anti-aliasing rasterizer from FreeType 2

QUrl::fromUserInput

Parts of the codecs implemented by Qt

Testlib

ANGLE

WebKit used by the QtWebKit module

Unicode

Macros for building Qt files

The PCRE library

V8 benchmark tests

Sunspider benchmark tests

Open Source Licensing of Qt

Trademarks

Mobile APIs

Supported Mobile Platforms

Sensors

Positioning

Location

Bluetooth

NFC

In-App Purchasing

All Classes by Module

All QML Modules

All QML APIs by Module

The qtmain Library

License Information

The QtOpenGLExtensions Library

License Information

All Overviews

Overviews

Modules

QML Modules

Third-party Android Libraries

Prerequisites

Including the Library in the Source

Adding the Library to the Project Dependencies

Deployment

Qt for Android

Getting Started with Qt for Android

Requirements

Installing Qt for Android

Adding OpenSSL Support

Porting to Android

Publishing to Google Play

Implementing Atomic Operations

Qt for Embedded Linux Fonts

FreeType

QPF2

QPF

FreeType Formats

Qt Prerendered Font (QPF2)

Legacy Qt Prerendered Font (QPF)

kmap2qmap

Qt for Embedded Linux

Configuring a Specific Device

Platform Plugins for Embedded Linux Devices

EGLFS

LinuxFB

Input

Using libinput

Input on eglfs and linuxfb without libinput

Mouse

Keyboard

Touch

Pen-based tablets

Debugging Input Devices

Using Custom Mouse Cursor Images

Display Output

eglfs with eglfs_kms backend

eglfs with eglfs_kms_egldevice backend

eglfs with other backends

Video Memory

linuxfb

Unix Signal Handlers

Platform Plugins for Windowing Systems on Embedded Linux Devices

XCB

Wayland

Related Topics

makeqpf

Qt for iOS - Building from Source

Qt for iOS

Getting Started

Setting Up the Development Environment

Building Applications From the Command Line

Building Applications with Qt Creator

Examples for iOS

Using Objective-C Code in Qt Applications

Related Topics

Platform Notes - iOS

Info.plist

Deployment

Information Property List Files

Application Assets

Icons

Launch Images

Publishing to Apple App Store

Porting to iOS

Qt for Linux/X11 - Building from Source

Step 1: Installing the License File (Commercial Editions Only)

Step 2: Unpacking the Archive

Step 3: Building the Library

Step 4: Set the Environment Variables

Qt for Linux/X11 - Deployment

Static Linking

Building Qt Statically

Linking the Application to the Static Version of Qt

Shared Libraries

Building Qt as a Shared Library

Linking the Application to Qt as a Shared Library

Creating the Application Package

Application Dependencies

Additional Libraries

Qt Plugins

Qt for Linux/X11 - Specific Issues

Linux

Installation problems

Intel C++ Compiler for Linux

Known Issues with Intel C++ Compiler for Linux

Known Issues with GCC Compilers

Qt for X11 Requirements

Platform Plugin Dependencies

OpenGL Dependencies

Multimedia Dependencies

Qt WebEngine Dependencies

Qt for Linux/X11

Downloading and Installing Qt

Requirements for Development Host

Debian/Ubuntu (apt-get)

Fedora/RHEL/CentOS (yum)

openSUSE (zypper)

Building Qt 5 from Source

Deployment and Other Issues

Where to Go from Here

Contributions to the Cocoa Platform Plugin Files

Cocoa Platform Plugin

Qt for macOS - Building from Source

Step 1: Install the License File (Commercial Editions Only)

Step 2: Build the Qt Library

Step 3: Set the Environment Variables

Qt for macOS - Deployment

The Bundle

Static Linking

Building Qt Statically

Linking the Application to the Static Version of Qt

Frameworks

Building Qt as Frameworks

Linking the Application to Qt as Frameworks

Creating the Application Package

Application Dependencies

Qt Plugins

Additional Libraries

macOS Version Dependencies

The Mac Deployment Tool

Qt for macOS - Specific Issues

Aqua

Qt Attributes for macOS

Right Mouse Clicks

Menu Bar

Special Keys

Dock

Accessiblity

Library and Deployment Support

Qt Libraries as Frameworks

Bundle-Based Libraries

Combining Libraries

Initialization Order

Compile-Time Flags

macOS Native API Access

Accessing the Bundle Path

Translating the Application Menu and Native Dialogs

Mixing Qt with Native Code

Using Native Cocoa Panels

Limitations

Fink

MySQL and macOS

D-Bus and macOS

Menu Actions

Native Widgets

Qt for macOS - Requirements

Required Compiler Versions

OS X on PowerPC hardware

Qt for macOS

Qt for OS X

Downloading and Installing Qt

Building Qt 5 from Source

macOS Versions

Additional Command-Line Options

Deploying Applications on macOS

macOS Issues

Where to Go from Here

Platform and Compiler Notes - Android

Android Development in Qt Creator

Application Package

Deployment

Deployment with Ministro

Deployment for Debugging

Plugins and Imports Special Considerations

Text Special Considerations

OpenGL Special Considerations

Multimedia Special Considerations

Assets File System

Supported Architectures

Platform Notes - INTEGRITY

INTEGRITY

Platform and Compiler Notes - QNX

QNX

Supported Architectures and QNX Releases

Supported Modules

Build Requirements

Qt Runtime Target Requirements

QNX Screen Graphics Subsystem

IPv6 Support

Random device <@op>/</@op>dev<@op>/</@op>random

System Logger

Environment Variables

Qt Runtime Location

Physical Screen Size

Troubleshooting the First Start of a Qt Application

Third Party Libraries

Accessing Environment Variables

Qt Creator Target Requirements

SSH

SCP and SFTP

QNX Tools for Remote Debugging

Other Utilities on the Target Device

Deployment Destination Folder

Platform and Compiler Notes - VxWorks

VxWorks

Qt Platform Abstraction

Class Overview

Supported Platforms and Configurations

Qt 5.6

Qt 5.5

Qt 5.4

Qt 5.3

Supported Platforms

Desktop Platforms

Community Supported Platforms

Supported Configurations

Reference Configurations

Availability of Packages

Deployment of Qt Applications

General Legal Disclaimer

Windows CE - Using shadow builds

Windows CE - Working with Custom SDKs

Creating a Custom Build Specification

Fine-Tuning Options

Cross-compilation Environment for a Custom SDK

Compiling Qt for a Custom SDK

Making Qt Applications Start on a Custom Device

Qt for Windows CE

Windows CE - Introduction to using Qt

Required Tools

Installing Qt

Building Your Own Applications

Running the Application

Qt for Windows CE and OpenGL ES

Introduction

Using OpenGL ES with Qt

Using OpenGL with Qt for Windows CE

Configure

Using OpenGL to Accelerate Normal 2D Painting

Windows CE - Signing

Signing on Windows CE

Qt for Windows - Building from Source

Step 1: Install the License File (Commercial Editions Only)

Step 2: Unpack the Archive

Step 3: Set the Environment Variables

Step 4: Build the Qt Library

Parallel Builds

Qt for Windows - Deployment

The Windows Deployment Tool

Static Linking

Linking the Application to the Static Version of Qt

Shared Libraries

Building Qt as a Shared Library

Linking the Application to Qt as a Shared Library

Creating the Application Package

Manifest files

Manual installations with Visual Studio 2008 and 2010

Application Dependencies

Additional Libraries

Qt Plugins

Qt for Windows - Specific Issues

Windows XP

Targeting XP with Visual Studio 2012 and later

Installation location

Possible GL conflict

GCC (MinGW-builds)

Intel C++ Compiler (Windows, Altix)

Visual Studio

Fullscreen OpenGL Based Windows

Qt for Windows - Requirements

Libraries

ICU

Graphics Drivers

Dynamically Loading Graphics Drivers

Building from Source

SDKs and Compilers

Qt for Windows

Downloading and Installing Qt

Building Qt 5 from Source

Deployment and Other Issues

Where to Go from Here

Visual Studio Add-in

Qt for WinRT

Requirements

Getting Started

Notes to Desktop Users

Building Applications

Building Applications with Visual Studio

Building Applications with Qt Creator

Building from Source

Running Applications from Command Line

Package Content

WinRT Runner Tool

Porting C++ Applications to Qt 5

Related Topics

Porting Guide

Related Topics

Porting QML Applications to Qt 5 Example

Related Topics

QML Applications

What is QML?

What is Qt Quick?

QML User Interfaces

Buttons, Menus, and other Controls

Special Effects

Viewing Web Content in QML Applications

Sensors, Gestures, and Touch Interfaces

Multimedia Content

Mobile Devices

Code Samples and Demos

Advanced Application Development Topics

Other QML Modules

Related Topics

QML Coding Conventions

QML Object Declarations

Grouped Properties

Lists

JavaScript Code

Debugging QML Applications

console log

console assert

console time

console timeEnd

console trace

console count

console profile

console profileEnd

console exception

declarative_debug

qml debug

Console API

Log

Assert

Timer

Trace

Count

Profile

Exception

Debugging Module Imports

QML Debugging Infrastructure

Enabling the Infrastructure

Starting Applications

Connecting to Applications

Debugging with Qt Creator

Deploying QML Applications

Deploying Applications with Qt Creator

Prototyping with QML Scene

Initializing the QML Runtime in Applications

Initializing with QQuickView

Creating a QQmlEngine directly

Managing Resource Files with the Qt Resource System

First Steps with QML

Creating a QML Document

Importing and Using the QtQuick Module

Defining an Object Hierarchy

Putting it All Together

Creating and Running QML Projects

Creating QML Applications with Controls

Handling User Input

Property Bindings

Animations

Defining Custom QML Types for Re-use

Where to Go from Here

Glossary Of QML Terms

Common Terms

Internationalization and Localization with Qt Quick

Internationalizing Your Application

1. Use qsTr() for all Literal User Interface Strings

2. Add Context for the Translator

3. Disambiguate Identical Texts

4. Use <@op>%</@op>x to Insert Parameters into a String

5. Use %Lx so Numbers are Localized

6. Internationalize Dates, Times and Currencies

7. Use QT_TR_NOOP() for Translatable Data Text Strings

8. Use Locale to Extend Localization Features

Localizing Your Application

Use a Conditional to Hide QML Source From the Compiler

Performance Considerations And Suggestions

Timing Considerations

Profiling

JavaScript Code

Bindings

Type-Conversion

Resolving Properties

Property Bindings

Sequence tips

Value-Type tips

Other JavaScript Objects

Common Interface Elements

Text Elements

Images

Asynchronous Loading

Explicit Source Size

Avoid Run-time Composition

Position Elements With Anchors

Models and Views

Custom C++ Models

ListModel QML Type

Populate Within A Worker Thread

Don't Use Dynamic Roles

Views

Visual Effects

Animations

Particles

Controlling Element Lifetime

Lazy Initialization

Using Loader

Using Dynamic Creation

Destroy Unused Elements

Rendering

Clipping

Over-drawing and Invisible Elements

Translucent vs Opaque

Shaders

Memory Allocation And Collection

Tips For QML Application Developers

Instantiate and initialize components lazily

Destroy unused objects

Don't manually invoke the garbage collector

Avoid complex bindings

Avoid defining multiple identical implicit types

Re-use existing components

Use singleton types instead of pragma library scripts

Memory Allocation in a QML Application

In-Depth Memory Allocation Considerations

Fragmentation

Garbage Collection

Implications of Garbage Collection

Manually Invoking the Garbage Collector

Memory vs Performance Trade-offs

Porting QML Applications to Qt 5

Qt Quick 1

QML Language Changes

QtQuick Module

Property and Method Changes

Type and API Changes

Behavioral Changes

Changes to experimental Qt.labs modules

C++ code

QDeclarativeItem and QDeclarativeView

qmlscene Utility

QML plugins

QtDeclarative module in Qt 5

Prototyping with qmlscene

Adding Module Import Paths

Loading Test Data

Qt Quick Test Reference Documentation

Introduction

Running Tests

Usecase - Animations In QML

Fluid UIs

States and Transitions

Animating Property Changes.

Other Animations

Use Case - Integrating JavaScript in QML

Using JavaScript Expressions for Property Values

Adding JavaScript Functions in QML

Using JavaScript Files

Use Case - Positioners and Layouts In QML

Manual Positioning

Anchors

Positioners

Layout Types

Use Case - Style And Theme Support

Using the Styling QML Types

Accessing the System Palette

Use Case - Displaying Text In QML

Displaying and Formatting Text

Laying Out Text

Example Code

Internationalization and Scalability

Use Case - Responding To User Input in QML

Supported Types of User Input

Mouse and Touch Events

Keyboard and Button Events

Use Case - Visual Elements In QML

The Rectangle Type

The Image Type

Shared Visual Properties

Opacity and Visibility

Transforms

What's New in Qt 5

Qt Everywhere on Mobile

Amazing Graphics Capability and Performance

Qt Quick in Qt 5

Designing UI Made Simpler

Sensor and Location

Web Engine and HTML5

Multimedia

Platform-specific Extras

Modularized Qt Libraries

Widgets in Qt 5

Provide Map-based Solutions with Qt

Qt Platform Abstraction

New Connection Syntax

Connectivity and Networking

Extended Connectivity

JSON Support

User Input

Related Topics

All Modules

Qt Essentials

Qt Add-Ons

Value-Add Modules

Technology Preview Modules

Qt Tools

Where to Go from Here

Qt Reference Pages

Class Lists

Function Lists

QML Reference

Qt Tool Manuals

Value-Add Features

Platform Reference

Scripting

Qt Script Module

JS API

QML

Differences between String-Based and Functor-Based Connections

Type Checking and Implicit Type Conversions

Making Connections to Lambda Expressions

Connecting C++ Objects to QML Objects

Using Default Parameters in Slots to Connect to Signals with Fewer Parameters

Selecting Overloaded Signals and Slots

C++ API changes

Changes to Qt Core

Changes to QAction

Changes to QChar

Changes to QCoreApplication

Changes to QEvent

Changes to QFile

Changes to QFont

Changes to QMetaType

Changes to QMetaMethod

Changes to QObject

Changes to QVariant

Changes to QAbstractEventDispatcher

Changes to QDir

Changes to QLocale

Changes to QAbstractItemModel

Changes to QString

Changes to QDate, QTime, and QDateTime

Changes to QTextCodec

Changes to QUrl

Changes to Qt Concurrent

Changes to Qt GUI

Changes to QAccessibleInterface

Changes to QImage

Changes to QPainter

Changes to QTouchEvent

Changes to Qt Widgets

Changes to QApplication

Changes to QStyle

Changes to QHeaderView

Changes to QAbstractItemView

Changes to QColorDialog

Changes to Qt WebKit

Changes to Qt Print Support

Changes to Qt Network

Changes to QSslCertificate

Changes to Qt SQL

Changes to Qt Test

Changes to Qt OpenGL

Changes to Qt Global

Changes to Tools

Related Topics

Testing and Debugging

Unit Testing

Autotests

Testing with Qt Creator

Debugging Techniques

Qt Overviews

Best Practices

Reference

User Interfaces

Common Important UI Topics

QML Graphical User Interfaces

Important UI Topics for QML Applications

Graphical Controls

Widget-based User Interfaces

Important Concepts in Qt Widgets

Visualizing Data

Displaying Web Content

Comparison

Internationalization and Translations

Integrating Web Content

WebEngine in Qt

Qt and HTML-JavaScript Hybrid Applications

What's New in Qt 5.0

Qt Core Changes

QStandardPaths

Compile-time Checks for Signal-slot Connections

Perl-Compatible Regular Expressions

Qt GUI Changes

New Classes for Windowing and Rendering

OpenGL Classes

QOpenGLPaintDevice

Qt Network Changes

QDnsLookup

Better Support for IPv6 and Dual-mode Networks

Binding TCP Sockets

SSL Certificates

Workarounds for Buggy SSL Servers

Support for Opaque Private Keys

Qt QML Changes

QML Engine

Type System

Other

Qt Quick Changes

New Graphics Architecture

Visual and Graphic Types

Animations

Text

User Input

Specialized Containers

Positioners

Models and Views

Particles System Support

Utility Types

Qt Multimedia Changes

New Classes and Functions

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.1

Additions to Other Qt 5 Releases

What's New in Qt 5.1

New Modules

New Supported Platforms

Summary of Changes

moc Changes

qmake Changes

Qt Core Changes

Qt GUI Changes

Qt Network Changes

Qt QML Changes

Qt Quick Changes

Qt WebKit Changes

Qt Widgets Changes

Qt Creator Compatibility

Other New Features

List of API Changes

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.2

Additions to Other Qt 5 Releases

What's New in Qt 5.2

New Modules

Support for New Platforms

Android

iOS

Qt Creator Updates

Installation Updates

New Features in Qt 5.2

Qt Core Module

Qt GUI Module

Qt Widgets Module

Qt Print Support Module

Qt QML Module

Qt Quick Module

Qt Quick Controls Module

Qt Quick Dialogs Module

Qt Quick Layouts Module

Qt Network Module

moc New Features

Accessibility New Features

WebKit New Features

List of API Changes

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.3

Additions to Other Qt 5 Releases

What's New in Qt 5.3

New Modules

New Platforms

New Features

Qt Core Module

Qt GUI Module

Qt Quick Module

Qt Quick Controls Module

Qt Quick Dialogs Module

Qt Network Module

Qt Multimedia Module

Qt WebKit Module

Qt Positioning Module

Qt Bluetooth Module

Qt QML Module

XInput2 Smooth Scrolling

Qt Creator 3.1

WinRT Plugin

Editors

C++

iOS

QML

Debugger

Devices

List of API Changes

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.4

Additions to Other Qt 5 Releases

What's New in Qt 5.4

New Modules

New Supported Platforms

New Features in Qt 5.4

Qt GUI Module

Qt Core Module

Qt Widgets Module

Qt Quick Module

Qt Quick Controls Module

Qt Bluetooth Module

QPA Plugins

Qt WebKit Module

Qt Windows Extras Module

Qt Sensors Module

Qt SQL Module

Deprecated Features

Qt OpenGL Module

List of API Changes

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.5

Additions to Other Qt 5 Releases

What's New in Qt 5.5

New Modules

New Features in Qt 5.5

Qt Bluetooth Module

Qt Core Module

Qt GUI Module

Qt Multimedia Module

Qt NFC Module

Qt Network Module

Qt Platform Abstraction (QPA)

Qt QML Module

Qt Quick Module

Qt Quick Controls Module

Qt WebEngine Module

Qt WebView Module

Deprecated Functionality

List of API Changes

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.6

Additions to Other Qt 5 Releases

What's New in Qt 5.6

New Modules

New Features in Qt 5.6

Qt 3D

Qt Core Module

Qt Canvas3D Module

Qt GUI Module

Qt Multimedia Module

Qt NFC Module

Qt Network Module

Qt Platform Abstraction (QPA)

Qt Positioning Module

Qt QML Module

Qt Testlib Module

Qt WebView Module

Qt WebEngine Module

Qt Widgets Module

Removed Functionality

Deprecated Functionality

List of API Changes

Additions to Other Qt 5 Releases

Accessibility Classes

List of Qt Examples

Best Practice Guides

IPC Examples

Tools Examples

Groups Of Related Classes

Qt Classes for Internationalization

Internationalization with Qt

Relevant Qt Classes and APIs

Languages and Writing Systems

Producing Translations

Enabling Translation

Support for Encodings

Localizing Numbers, Dates, Times and Currency

Dynamic Translation

System Support

Unix/X11

Linux

Windows

macOS

Related Pages

Qt Licensing

Purchasing and Sales Information

Licenses Used in Qt

Additional information

All C++ APIs per Module

ActiveX in Qt

UI Design with Qt

Qt Concurrent Examples

Qt Concurrent Examples

Qt SQL Examples

Classes for String Data

Threading Classes

Touch Input Examples

Qt XML Examples