Qt Reference Documentation

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

ANGLE

About JavaScript

About SVG

Scalable Vector Graphics

Accessibility

Introduction

Making Applications Accessible

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 for Qt Quick Applications

Introduction

AccessibleEventID.idl File Reference

ActivePerl

ActiveQt Examples

Adding OpenSSL Support for Android

All Classes

All Classes by Module

All Functions

All Modules

Qt Essentials

Qt Add-Ons

Value-Add Modules

Technology Preview Modules

Qt Tools

Where to Go from Here

All Namespaces

All Overviews

Overviews

Modules

QML Modules

All QML Basic Types

All QML Modules

All QML APIs by Module

All QML Types

All Qt Examples

Android APK

Android GNU C++ Run-time Licensing

Information About The GNU C++ Run-time License From GCC Headers

The GCC Run-time Library Exception

Information About The LLVM C++ Run-time License

Android Services

Android: App Manifest

Animation Framework Examples

Annotated Class List

App Icons on iPhone, iPad and Apple Watch

Apple Developer Program

Arora Browser

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

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

Bluetooth SIG

Boot2Qt

Building Monolith Project

Building Monolith Project

Defining Project with Project Wizard

Project Manager Settings

Adding File System Mount Point

Galcore VAS Settings

Values in Attributes Tab

Editing Galcore Project

File galcore.c

File galcore.gpj

File kernel.gpj

File monolith.gpj

.int File

Building monolith.gpj

Building Qt 5 From Git

Building Qt 5 for Android

Building Qt Sources

General Installation Information

Windows

macOS

Linux/X11

Embedded Linux

Android

iOS

WinRT

Building Qt for i.MX6 Quad Board

Creating Script for Running Exports

Getting Qt Source Code

Getting Qt Sources via Git

Configuring Qt

Building Qt

Installing Qt

Building U-Boot Image

Building and Running Example

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

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

C++ Reference - memcpy

CMake AUTOMOC Documentation

CMake Documentation

CMake LOCATION Documentation

CMake Manual

Getting Started

Imported targets

Variable Reference

Module variables

Installation variables

Macro Reference

Qt5Core macros

Qt5Widgets macros

Qt5DBus macros

Qt5LinguistTools macros

CMake POSITION_INDEPENDENT_CODE Documentation

CMake find_package Documentation

CMake target_link_libraries Documentation

Calling Qt Functions From Unix Signal Handlers

Class and Function Documentation

Class Lists

Function Lists

Coffee Machine Example

Common Unix Printing System (CUPS)

CUPS

Configuring Qt Creator

Contributing to Qt

Core Internals

Objects, Properties, and Events

Container Classes

Internationalization

Inter-Process Communication

Threading

Platform Support

Create asset catalogs and sets

Creating Bootable SD Card

Creating Shared Libraries

Using Symbols from Shared Libraries

Header File Considerations

Binary Compatibility

Creating a Mobile Application

Creating a Qt Widget Based Application

Data Storage

Saving and Loading Data

SQL Support in Qt

XML Support in Qt

JSON in Qt

Local Storage

QSettings Class

Resources

File Archiving

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

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

Dependency Walker

Deploying Plugins

The Plugin Directory

Loading and Verifying Plugins Dynamically

Debugging Plugins

Deploying QML Applications

Deploying Applications with Qt Creator

QML Caching

Compiling QML Ahead of Time

Limitations

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

Deploying Qt Applications

Static vs. Shared Libraries

Deploying Qt's Libraries

Licensing

Platform-Specific Notes

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

Desktop Entry Specification

Desktop Integration

Useful Classes

Opening External Resources

System Tray Icons

Desktop Widgets

Development Tools

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

Direct X SDK

DirectFB - CreateInputEventBuffer

DirectFB - DFBSurfaceBlittingFlags

DirectFB - DFBSurfaceDescription

DirectFB - IDirectFBImageProvider

DirectFB - IDirectFBPalette

DirectFB - IDirectFBSurface

DirectFB - IDirectFBWindow

DirectFB - df_window example

Downloads

Drag and Drop Examples

ECMAScript Language Specification

Eclipse Plugin

Emulator

Enginio Manual

Exception Safety

Exception Safe Modules

Containers

Out of Memory Handling

Recovering from Exceptions

Exceptions in Client Code

Signals and Slots

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

Framebuffer HOWTO

GNOME

GNU Emacs

GNU Free Documentation License

GNU Free Documentation License (FDL)

GNU General Public License

GNU General Public License (GPL)

GPL version 3

GNU General Public License, version 2

GNU General Public License, version 3

GNU Lesser General Public License (LGPL)

LGPL version 3

GNU Lesser General Public License, version 2.1

GNU Lesser General Public License, version 2.1

GNU Lesser General Public License, version 3

Gestures Examples

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 with Qt

Install Qt

Platform Requirements

Create Your First Applications

Explore Qt

Setting Up Projects

Developing with Qt Creator

Reference Documentation

Qt Project Community

Getting Started with Qt for Android

Installing the Prerequisites

Updating the Android SDK

Configuring Your Development Host

Windows

64-bit Linux

Qt Creator IDE

Testing Your Setup

Glossary Of QML Terms

Common Terms

GnuWin32 Project

Google Play Developer Console

Google Play: Flyingbus

Google Play: Introduction to Qt 5

Google Play: Qt 5 Everywhere

Google Play: Qt Hangman

Google Play: Quick Forecast

Graphics

2D Graphics with QPainter

OpenGL and 3D

Qt Quick Scene Graph

Printing

Images

HTML 4

HTML 5

HTML5 Web Database API

How to Report a Bug

How to compress data with Qt?

ICU

Icon Themes Specification

Implementing Atomic Operations

Inheritance Hierarchy

Installing Platform Dependencies

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

9. Prepare for Dynamic Language Changes

Localizing Your Application

Use a Conditional to Hide QML Source From the Compiler

JavaScript Guide

JavaScript Reserved Words

JavaScript Resources

KDE

KDE applications

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

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

IDC - The Interface Description Compiler (ActiveQt)

Integrating Web Content

WebEngine in Qt

Qt and HTML-JavaScript Hybrid Applications

Inter-Process Communication in Qt

TCP/IP

Shared Memory

D-Bus protocol

QProcess Class

Session Management

Khronos OpenGL ES API Registry

Known Issues

LLVM Attribution

Layout Examples

License Changes

Qt 5.11.2

Qt Core Module

Qt GUI Module

Qt Location Module

Qt SQL Module

Qt WebEngine Module

Qt 5.11.1

Qt 3D Module

Qt Documentation

Qt Image Formats

Qt 5.11.0

Qt 3D Module

Qt Core Module

Qt D-Bus Module

Qt GUI Module

Qt Image Formats

Qt Quick Controls 2 Module

Qt SQL Module

Qt Test Module

Qt WebEngine Module

Qt XML Patterns Module

License of Qt examples

Licenses Used in Qt

Third-Party Licenses Used in Qt

Livecoding video effects with Qt5

Mac OS X Aqua

Macros for Building with CMake

Mesa llvmpipe

Microsoft Active Accessibility Event Constants

MinGW

Mitigating Cross-site Scripting With HTTP-only Cookies

Mobile APIs

Supported Mobile Platforms

Sensors

Positioning

Location

Bluetooth

NFC

In-App Purchasing

Mobile SVG Profiles

Motif Extension

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

Netscape Cookie Specification

Networking and Connectivity

Network Communication

WebSockets

World Wide Web Support

Inter-Process Communication

Serial Port Communication

Bluetooth Communication

Near Field Communication

New Classes and Functions in Qt 5.1

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.10

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.11

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.2

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.3

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.4

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.5

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.6

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.7

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.8

Additions to Other Qt 5 Releases

New Classes and Functions in Qt 5.9

Additions to Other Qt 5 Releases

New and Modified BSD Licenses

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

Officially Supported Platforms

Open Source Licensing of Qt

OpenGL Instanced Rendering

OpenGL Primitive Restart

OpenGL Registry

OpenGL glTF

OpenSSL Configure Options

OpenSSL Toolkit

OpenSSL: Build Setup Script

Overview of Qt's Undo Framework

Undo framework

Introduction

Classes

Concepts

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

Avoid Smoothing Images

Painting

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

Reuse 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

Pimp my video

Platform Notes - iOS

Info.plist

Deployment

Information Property List Files

Application Assets

Icons

Launch Images

Native Image Picker

Expressing Supported iOS Versions

Publishing to Apple App Store

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 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

Porting C++ Applications to Qt 5

Related Topics

Porting Guide

Related Topics

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

Porting QML Applications to Qt 5 Example

Related Topics

Porting to Android

Porting to iOS

PostgreSQL MinGW/Native Windows

Preparing BSP for i.MX6 Quad Board

Preparing U-Boot

Prototyping with qmlscene

Adding Module Import Paths

Loading Test Data

Pthreads Programming: A POSIX Standard for Better Multiprocessing

Public Qt Repository

Publishing to Google Play

Python

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 Book

QML Coding Conventions

QML Object Declarations

Grouped Properties

Lists

JavaScript Code

Related Information

Qbs Manual

Qt 4.8 Reference Documentation

Qt 5.11

Qt Reference Documentation

Qt Framework

Qt Creator IDE

Tools and Toolchains

Licenses Used in Qt

Reference

Getting Started

Overviews

Qt Account

Qt Account Sign-up

Qt Add-ons

Qt Automotive Suite

Qt Bug Tracker

Qt Centre

Qt Cloud Services

Qt Coding Style

Qt Commercial License

Purchasing and Sales Information

Qt Configuration Tool

Qt Configure Options

Source, Build, and Install Directories

Modules and Features

Excluding Qt Modules

Including or Excluding Features

Third-Party Libraries

Compiler Options

Cross-Compilation Options

Specific Options for Platforms

OpenGL Options for Windows

Qt Creator Manual

Qt Creator: Acknowledgements

Qt Creator: Adding Bindings Between Properties

Qt Creator: Adding Compilers

Qt Creator: Adding Connections

Qt Creator: Adding Debuggers

Qt Creator: Adding JSON-Based Wizards

Qt Creator: Adding Kits

Qt Creator: Adding Libraries to Projects

Qt Creator: Adding New Custom Wizards

Qt Creator: Adding Qt Designer Plugins

Qt Creator: Adding Qt Versions

Qt Creator: Adding States

Qt Creator: Adding XML-Based Wizards

Qt Creator: Advanced Use

Qt Creator: Analyzing CPU Usage

Qt Creator: Analyzing Code

Qt Creator: Beautifying Source Code

Qt Creator: Browsing ISO 7000 Icons

Qt Creator: Building and Running

Qt Creator: Building and Running an Example

Qt Creator: Building for Multiple Platforms

Qt Creator: Checking Code Syntax

Qt Creator: Coding

Qt Creator: Comparing Files

Qt Creator: Completing Code

Qt Creator: Configuring Projects

Qt Creator: Configuring Qt Creator

Qt Creator: Configuring the Editor

Qt Creator: Connecting Android Devices

Qt Creator: Connecting Bare Metal Devices

Qt Creator: Connecting Devices

Qt Creator: Connecting Embedded Linux Devices

Qt Creator: Connecting Objects to Signals

Qt Creator: Connecting QNX Devices

Qt Creator: Connecting iOS devices

Qt Creator: Creating Buttons

Qt Creator: Creating C++ Classes

Qt Creator: Creating Components

Qt Creator: Creating Projects

Qt Creator: Creating Qt Quick Projects

Qt Creator: Creating Scalable Buttons and Borders

Qt Creator: Creating a Mobile Application

Qt Creator: Creating a Qt Quick Application

Qt Creator: Creating a Qt Widget Based Application

Qt Creator: Customizing the Build Process

Qt Creator: Debugging

Qt Creator: Debugging Qt Quick Projects

Qt Creator: Debugging a C++ Example Application

Qt Creator: Debugging a Qt Quick Example Application

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 Devices

Qt Creator: Designing User Interfaces

Qt Creator: Detecting Memory Leaks with Heob

Qt Creator: Detecting Memory Leaks with Memcheck

Qt Creator: Developing Qt Quick Applications

Qt Creator: Developing Widget Based Applications

Qt Creator: Editing MIME Types

Qt Creator: Editing PathView Properties

Qt Creator: Editing QML Files in Design Mode

Qt Creator: Editing State Charts

Qt Creator: Exporting Designs from Graphics Software

Qt Creator: FAQ

Qt Creator: Finding

Qt Creator: Finding and Replacing

Qt Creator: Getting Help

Qt Creator: Getting Started

Qt Creator: Glossary

Qt Creator: IDE Overview

Qt Creator: Indenting Text or Code

Qt Creator: Interacting with the Debugger

Qt Creator: Keyboard Shortcuts

Qt Creator: Known Issues

Qt Creator: Launching the Debugger

Qt Creator: Managing C++ Backend Objects

Qt Creator: Managing Item Hierarchy

Qt Creator: Managing Projects

Qt Creator: Managing Sessions

Qt Creator: Modeling

Qt Creator: Opening Projects

Qt Creator: Optimizing Applications for Mobile Devices

Qt Creator: Parsing C++ Files with the Clang Code Model

Qt Creator: Pasting and Fetching Code Snippets

Qt Creator: Profiling Function Execution

Qt Creator: Profiling QML Applications

Qt Creator: Qt Quick UI Forms

Qt Creator: Refactoring

Qt Creator: Running Autotests

Qt Creator: Running Valgrind Tools on External Applications

Qt Creator: Running on Multiple Platforms

Qt Creator: Searching with the Locator

Qt Creator: Semantic Highlighting

Qt Creator: Setting Up CMake

Qt Creator: Setting Up Debugger

Qt Creator: Setting Up Qbs

Qt Creator: Setting Up a Generic Project

Qt Creator: Setting Up an Autotools Project

Qt Creator: Sharing Project Settings

Qt Creator: Showing Task List Files in Issues Pane

Qt Creator: Specifying Build Settings

Qt Creator: Specifying Code Style Settings

Qt Creator: Specifying Dependencies

Qt Creator: Specifying Dynamic Properties

Qt Creator: Specifying Editor Settings

Qt Creator: Specifying Item Properties

Qt Creator: Specifying Run Settings

Qt Creator: Specifying Text Editor Settings

Qt Creator: Supported Platforms

Qt Creator: Technical Support

Qt Creator: Testing

Qt Creator: Tips and Tricks

Qt Creator: Troubleshooting Debugger

Qt Creator: Tutorials

Qt Creator: User Interface

Qt Creator: Using Bazaar

Qt Creator: Using CVS

Qt Creator: Using Clang Tools

Qt Creator: Using ClearCase

Qt Creator: Using Command Line Options

Qt Creator: Using Debugging Helpers

Qt Creator: Using External Tools

Qt Creator: Using FakeVim Mode

Qt Creator: Using Git

Qt Creator: Using Mercurial

Qt Creator: Using Other Build Systems

Qt Creator: Using Perforce

Qt Creator: Using QML Modules with Plugins

Qt Creator: Using Qt Quick Toolbars

Qt Creator: Using Subversion

Qt Creator: Using Text Editing Macros

Qt Creator: Using Valgrind Code Analysis Tools

Qt Creator: Using Version Control Systems

Qt Creator: Using the Help Mode

Qt Creator: Working in Edit Mode

Qt Creator: Writing Code

Qt Enterprise

Qt Examples And Tutorials

Running the Examples

Community Examples

All Examples

Qt FTP

Qt HTTP

Qt Homepage

Qt Licensing

Purchasing and Sales Information

Licensed Code in Qt

Qt Licensing Overview

Qt Licensing Overview

Qt Multimedia Backends

Qt Overviews

Best Practices

Reference

Qt Platform Abstraction

QPA Minimal Plugins

Class Overview

QPA Plugins

Qt Quarterly

Qt Quarterly: Another Look at Events

Qt Quarterly: Plural Form in Translation

Qt Quick 1 Reference Documentation

Qt Quick 2D Renderer

Qt Quick Compiler

Qt Quick Enterprise Controls

Qt Quick Text Editor - Connecting Actions

Importing the DocumentHandler QML Type

Assigning Actions

Deploying TextEditor

Example Files

Qt Quick Text Editor Guide

Application Design

Setting Up the Environment and Project

Project Files

Resource Files

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 Reference Pages

Class Lists

Function Lists

QML Reference

Qt Tool Manuals

Value-Add Features

Platform Reference

Qt VS Tools

Qt WebKit

Qt WebKit Widgets

Qt for Android

Qt for Android Examples

Running the Examples

Essentials

Qt Quick and QML Examples for Android

Qt for Automation

Qt for Device Creation

Qt for Device Creation: Supported Target Devices and Development Hosts

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

Advanced eglfs_kms features

eglfs with eglfs_kms_egldevice backend

Touch input in systems with multiple screens on KMS/DRM

eglfs with other backends

Video Memory

linuxfb

Unix Signal Handlers

Fonts

Platform Plugins for Windowing Systems on Embedded Linux Devices

XCB

Wayland

Qt Quick WebGL

Configuration and Use

Limitations

Related Topics

Qt for Embedded Linux Fonts

FreeType

QPF2

QPF

FreeType Formats

Qt Prerendered Font (QPF2)

Legacy Qt Prerendered Font (QPF)

Qt for INTEGRITY

INTEGRITY

Supported Qt Modules

Supported Development Hosts and Boards

Qt for INTEGRITY: Monolith Project Tutorial

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

Qt for Linux/X11 - Building from Source

Step 1: Installing the License File (Commercially Licensed Qt 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 VxWorks

VxWorks

Supported Architectures and VxWorks Releases

Qt for VxWorks Source Package

Requirements for VxWorks

QtWidget Applications

Qt Quick 2 Applications

Supported Modules

Limitations for Essential modules

Supported Add-ons

Platform Notes

Configuring for a Specific Device

Building and Installing Qt 5

Platform Plugins for VxWorks Devices

EGLFS

Qt Quick Scene Graph Rendering Thread

VxWorksFB

Input

Input on eglfs and vxworksfb

Mouse

Keyboard

Touch

Debugging Input Devices

Using Custom Mouse Cursor Images

QML Component Loader Thread

Preventing Timeouts in QEventDispatcher

Running Qt Applications

Limitations

OpenSSL Support

Video Memory

vxworksfb

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

Qt for Windows

Downloading and Installing Qt

Building Qt 5 from Source

Deployment and Other Issues

Where to Go from Here

Visual Studio Tools

Qt for Windows - Building from Source

Step 1: Install the License File (Commercially Licensed Qt 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

Application Dependencies

Additional Libraries

Qt Plugins

Qt for Windows - Requirements

Libraries

ICU

Graphics Drivers

Dynamically Loading Graphics Drivers

Building from Source

Compilers

Visual Studio

Intel C++ Compiler (Windows, Altix)

GCC (MinGW-builds)

Clang(clang-cl)

Building Qt WebEngine

QDoc Dependencies

Qt for Windows - Specific Issues

Library Naming

Installation location

Possible GL conflict

Visual Studio

Fullscreen OpenGL Based Windows

Qt for X11 Requirements

Platform Plugin Dependencies

OpenGL Dependencies

Multimedia Dependencies

Qt WebEngine Dependencies

QDoc Dependencies

Qt for iOS

Getting Started

Setting Up the Development Environment

Building Applications From the Command Line

Building Applications with Qt Creator

Using Objective-C Code in Qt Applications

Examples for iOS

Related Topics

Qt for iOS - Building from Source

Qt for iOS Examples

Running the Examples

Essentials

Qt Quick Examples for iOS

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

Qt for macOS - Building from Source

Step 1: Install the License File (Commercially Licensed Qt Only)

Step 2: Unpack the Archive

Step 3: Build the Qt Library

Step 4: 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

Expressing Supported macOS Versions

The Mac Deployment Tool

Qt for macOS - Requirements

Required Compiler Versions

OS X on PowerPC hardware

QDoc Dependencies

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

QtMediaHub

QtonPi

RFC 1036

RFC 1179

RFC 1738

RFC 1928

RFC 1929

RFC 2045

RFC 2109

RFC 2822

RFC 2965

RFC 3174

RFC 3491

RFC 3986

RFC 850

Reentrancy and Thread-Safety

Reentrancy

Thread-Safety

Notes on Qt Classes

Resource Compiler (rcc)

Restoring a Window's Geometry

SQL Examples

SVG 1.2 Tiny

SVG 1.2 Tiny Static Features

SVG Working Group

SVG color keyword names

Sailfish OS

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

Scripting

Qt Script Module

JS API

QML

Session Management

Shutting a Session Down

Protocols and Support on Different Platforms

Getting Session Management to Work with Qt

Testing and Debugging Session Management

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

Standard Accelerator Keys

Standard CSS2 selector

State Chart XML: State Machine Notation for Control Abstraction

State Machine Examples

Statecharts: A visual formalism for complex systems

Sun Studio Patches

Supported Platforms

Desktop Platforms

Community Supported Platforms

Supported Configurations

Reference Configurations

Availability of Packages

Deployment of Qt Applications

General Legal Disclaimer

Supported Platforms and Configurations

Qt 5.11

Qt 5.10

Qt 5.9

Qt 5.8

Qt 5.7

Qt 5.6

Qt 5.5

Synchronizing Threads

Low-Level Synchronization Primitives

Risks

Convenience classes

High-Level Event Queues

TDM-GCC

Testing and Debugging

Unit Testing

Autotests

Testing with Qt Creator

Debugging Techniques

The Active Qt framework

License Information

The Chromium Projects

The K Desktop Environment

KDE

The LLDB Debugger

The Qt Company

The qtmain Library

License Information

Third Party Libraries

Source Code

Library Files

Destination Directory

Third-party Android Libraries

Prerequisites

Including the Library in the Source

Adding the Library to the Project Dependencies

Deployment

Thread Support in Qt

Topics:

The Threading Classes

Thread Time: The Multithreaded Programming Guide

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

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

Threading and Concurrent Programming Examples

Threads Primer: A Guide to Multithreaded Programming

Threads and QObjects

QObject Reentrancy

Per-Thread Event Loop

Accessing QObject Subclasses from Other Threads

Signals and Slots Across Threads

Titillium Web Font

Tizen

Trademarks

Trafikanten

Translation Rules for Plurals

Unicode in Qt

Unicode

Qt's Classes for Working with Strings

Information about Unicode on the Web

Unicode in Qt

Use Case - Displaying Text In QML

Displaying and Formatting Text

Laying Out Text

Example Code

Internationalization and Scalability

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 - Responding To User Input in QML

Supported Types of User Input

Mouse and Touch Events

Keyboard and Button Events

Use Case - Style And Theme Support

Using the Styling QML Types

Accessing the System Palette

Use Case - Visual Elements In QML

The Rectangle Type

The Image Type

Shared Visual Properties

Opacity and Visibility

Transforms

Use case - Animations In QML

Fluid UIs

States and Transitions

Animating Property Changes.

Other Animations

User Interface Compiler (uic)

Options

Examples

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

Using qt.conf

Format and Location

Overriding Paths

Configuring Arguments to the Platform Plugins

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

W3C XML specifications

WebKit Open Source Project

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

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

Changes to the Text types

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

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

What's New in Qt 5.10

New Features in Qt 5.10

Qt Connectivity Module

Qt Graphical Effects Module

Qt GUI Module

Qt Network Module

Qt Quick Module

Qt Quick Controls 2 Module

Qt SerialBus Module

Qt Virtual Keyboard Module

Qt WebEngine Module

Qt Widgets Module

New Modules

Technology Preview Modules

Deprecated Functionality

List of API Changes

Additions to Other Qt 5 Releases

What's New in Qt 5.11

New Features in Qt 5.11

Qt Core Module

Qt Network Module

Qt QML Module

Qt Quick Module

Qt Quick Controls 2 Module

Qt 3D Module

Qt Location Module

Qt WebEngine Module

QDoc Documentation Generator

Qt Designer Tool

Qt GUI Module

Qt Widgets Module

Qt Serial Bus Module

Qt Bluetooth Module

New Modules

Platform Changes

Technology Preview Modules

Deprecated Modules

List of API Changes

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

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

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

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

What's New in Qt 5.6

New Modules

New Features in Qt 5.6

Qt 3D Module

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

What's New in Qt 5.7

New Modules

New Features in Qt 5.7

Qt 3D Module

Qt Core Module

Qt Canvas3D Module

Qt GUI Module

Qt Multimedia Module

Qt Platform Abstraction (QPA)

Qt QML Module

Qt Quick Module

Qt WebEngine Module

Qt Widgets Module

Removed Functionality

Deprecated Functionality

List of API Changes

Additions to Other Qt 5 Releases

What's New in Qt 5.8

New Features in Qt 5.8

Qt Core Module

Qt GUI Module

Qt Quick Module

Qt Quick Controls 2 Module

Qt WebEngine Module

Qt Bluetooth Module

Qt Multimedia Module

Qt Network Module

Qt WebSockets Module

Qt Charts Module

Qt 3D Module

Embedded Platforms

Configurability (Qt Lite Project)

New Modules

Technology Preview Modules

Deprecated Functionality

Removed Functionality

List of API Changes

Additions to Other Qt 5 Releases

What's New in Qt 5.9

New Features in Qt 5.9

Qt Core Module

Qt GUI Module

Qt Multimedia Module

Qt Network Module

Qt QML Module

Qt Quick Module

Qt Quick Controls 2 Module

Qt 3D Module

Qt Bluetooth Module

Qt Charts Module

Qt Location Module

Qt NFC Module

Qt SerialBus Module

Qt Virtual Keyboard Module

Qt WebEngine Module

Qt WebSockets Module

Embedded Platforms

New Modules

Technology Preview Modules

Platform Changes

Deprecated Functionality

List of API Changes

Additions to Other Qt 5 Releases

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

Win32 Multithreaded Programming

Windows Store: QuickForecast

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

XEmbed Specification

XML Bookmark Exchange Language Resource Page

XML Examples

XML Schema

XaoS

Xcode

error handling in the XQuery language

ext: Qt for VxWorks

external: Translating Qt Into Other Languages

freedesktop.org

http://linux.sybase.com

http://www.freetds.org

http://www.postgresql.org

http://www.sqlite.org

http://www.sybase.com

http://www.unixodbc.org

iTunes: Flyingbus

iTunes: Qt Hangman

iTunes: QtQuicksand

iTunes: Quick Forecast

iTunes: SubAttack

jom

kmap2qmap

libusb

macOS

publicsuffix.org

qsslkey example

qtestlib-tools

makeqpf

testcon - An ActiveX Test Container (ActiveQt)

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

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