Qt Reference Documentation

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

ANGLE

About JavaScript

About SVG

Scalable Vector Graphics

Accessibility

Introduction

Scalable UI

Keyboard Navigation

Colors & Color Contrast

Sound & Speech

Assistive Tools

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

Related Classes

AccessibleEventID.idl File Reference

ActivePerl

Adding OpenSSL Support for Android

Building OpenSSL for Android

Using OpenSSL Libraries with Qt for Android

AdoptOpenJDK

All Classes

All Classes by Module

All Functions

All Modules

Qt Essentials

Qt Add-Ons

Qt Add-Ons in Technical Preview

Where to Go from Here

All Namespaces

All Overviews

Overviews

Modules

QML Modules

All QML Modules

All QML APIs by Module

All QML Types

All QML Value Types

All Qt Examples

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

Android Development in Qt Creator

Application Package

Plugins and Imports Special Considerations

Text Special Considerations

OpenGL Special Considerations

Assets File System

Android Supported Architectures

Known Issues

Limitations

Frequently Asked Questions

Android Services

Extending QtActivity AndroidManifest.xml

Assemble the Service

Create the Service Class

Start the Service

Start a Service On Demand

Start a Service At Boot Time

Manage the Service in AndroidMnifest.xml

Service in the Same Process as QtActivity

Service in Separate Process

Use the Same .so Lib File

Use a Separate .so Lib File

Communication with the Service

Native C++ Calls from Java Service

Using Android BroadcastReceiver

Using Qt Remote Objects

Prepare the replica

Connect the source and replica

Using QAndroidBinder

Android: <uses-feature>

Android: <uses-permission>

Android: Accessing original files

Android: Activity

Android: Add build dependencies

Android: Android Emoji Policy

Android: Android Emulator

Android: Android SDK Build Tools

Android: Android SDK Platform Tools

Android: Android SDK Platforms

Android: Android Studio

Android: Android command line tools

Android: Android keystore system

Android: App Bundles

Android: App Manifest

Android: App Manifest <activity>

Android: App Manifest <application>

Android: App Manifest <manifest>

Android: App Manifest <meta-data>

Android: App Versioning

Android: Binder

Android: BroadcastReceiver

Android: Build Configuration Files

Android: Build Numbers

Android: Create Deep Links to App Content

Android: Downloadable Fonts Process

Android: Font Provider Certificates

Android: Foreground services

Android: Fragments

Android: GMS Font Provider Certificates

Android: Google Downloadable Fonts

Android: Intent

Android: Introduction to Activities

Android: JobIntentService

Android: Query for devices

Android: Service

Android: Support Library

Android: Tagged Pointers

Android: The Android NDK

Android: Update your tools with the SDK Manager

Android: Verify Android App Links

Android: adb

Android: sdkmanager

Android: sendBroadcast()

Android: startService()

Animation Framework Examples

Annotated Class List

App Icons on iPhone, iPad and Apple Watch

Apple Developer Program

Arora Browser

Array Texture

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

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

Base Classes

Classes

InAppProduct

InAppStore

Initializing the store

Completing a purchase

Restoring purchases

InAppTransaction

InAppPurchaseBackend

Bluetooth SIG

Boot to Qt

Qt for Device Creation

Build Qt with Ubuntu host

Build Qt with Windows 10 host

Build System Changes in Qt 6

Building Qt from Sources

CMake, Ninja as External Dependencies

Selecting a Qt License

Re-running configure

Building only Parts of Qt

Resolving Third-Party Libraries

Selecting the Toolchain

Cross-Compiling Qt

Porting Qt Plugins and Additional Libraries

Build Additional Libraries through Conan

Related Topics

Building Qt 5 From Git

Building Qt Sources

General Installation Information

Windows

macOS

Linux/X11

Embedded Linux

Android

iOS

Module-specific System Requirements

Additional Information

Building Qt for QNX

Setting up QNX SDP

Host build

Creating a toolchain file for QNX

Configuring and building Qt for QNX

Third party libraries

Building Qt for Qualcomm Snapdragon 8155P Board on Ubuntu

Creating a set environment shell script

Getting Qt sources

Building Qt Desktop for cross-compiling tools usage

Creating a toolchain file for INTEGRITY

Configuring Qt for INTEGRITY

Building Qt for INTEGRITY

Installing Qt

Building Qt for Qualcomm Snapdragon 8155P Board on Windows 10

Creating a batch script for Windows 10

Getting Qt sources

Building Qt Desktop for cross-compiling tools usage

Creating a toolchain file for INTEGRITY

Configuring Qt for INTEGRITY

Building Qt for INTEGRITY

Installing Qt

Building a monolith project

Building the Qt application

Building a monolith project

Building and flashing a Dynamic Download Project

Preparing the Qt application build environment

Building the Qt application example

Creating a Dynamic Download Project in MULTI

Building a Dynamic Download Project

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

C++ Reference - memcpy

CMake AUTOMOC Documentation

CMake AUTORCC Documentation

CMake AUTOUIC Documentation

CMake CMAKE_PREFIX_PATH documentation

CMake CMAKE_TOOLCHAIN_FILE documentation

CMake Documentation

CMake LOCATION Documentation

CMake MACOSX_BUNDLE_INFO_PLIST documentation

CMake POSITION_INDEPENDENT_CODE Documentation

CMake Tutorial

CMake add_subdirectory documentation

CMake find_package Documentation

CMake iOS archiving failure issue

CMake target_include_directories documentation

CMake target_link_libraries Documentation

Calling Qt Functions From Unix Signal Handlers

Changes to Qt Extras Modules

Changes to Qt Mac Extras

QtMac namespace

QMacPasteboardMime

QMacToolBar

Changes to Qt Windows Extras

QtWin namespace

errorStringFromHresult

colorizationColor/isCompositionOpaque

setWindowFlip3DPolicy

extendFrameIntoClientArea

enableBlurBehind

taskbarActivateTab and taskbar(Add/Delete)Tab

QWinMime

QWinJumpList

QWinTaskbarButton

QWinThumbnailToolBar

Changes to Qt X11 Extras

Changes to Qt Android Extras

QAndroidJniObject and QAndroidJniEnvironment

QtAndroid namespace

Changes to Qt Modules in Qt 6

Related Topics

Class and Function Documentation

Class Lists

Function Lists

Coffee Machine Example

Common Unix Printing System (CUPS)

CUPS

Conan

Configure an Embedded Linux Device

Toolchain Files versus Device Makespecs

Host Tools

Configuring Qt

An Example Toolchain File

Building Applications for the Target Device

Defaults for Platform Plugins and EGLFS

Configuring Qt Creator

Contributing to Qt

Core Internals

Objects, Properties, and Events

Container Classes

Internationalization

Inter-Process Communication

Threading

Platform Support

Create Your First Applications

CreateProcess

Creating Shared Libraries

Using Symbols from Shared Libraries

Header File Considerations

Binary Compatibility

Creating a Qt Widget Based Application

Data Input Output

Saving and Loading Data

Serialized data

Database

XML Support in Qt

JSON in Qt

Local Storage

QSettings Class

Resources

Connectivity

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

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

Demo Android Classes

Classes

AndroidInAppProduct

AndroidInAppTransaction

AndroidInAppPurchaseBackend

Initialize

Purchasing

InAppPurchase.java and androidjni.cpp

Demo iOS Classes

Classes

IosInAppPurchaseProduct

IosInAppPurchaseTransaction

IosInAppPurchaseBackend

Initializing the products

Purchasing process

Dependency Walker

Deploying Plugins

The Plugin Directory

Loading and Verifying Plugins Dynamically

Debugging Plugins

Deploying QML Applications

Compiling Ahead of Time

Deploying Applications with Qt Creator

QML Caching

Ahead-of-Time Compilation

qmake

Prototyping with QML Scene

Initializing the QML Runtime in Applications

Initializing with QQuickView

Creating a QQmlEngine Directly

Using the Qt Resource System with QML

Related Information

Deploying Qt Applications

Static vs. Shared Libraries

Deploying Qt's Libraries

Licensing

Platform-Specific Notes

Deploying an Application on Android

Android Application Bundle

Generating the Application Bundle

Android Package Templates

AndroidManifest.xml

Java Code

Resources

libs.xml

strings.xml

Gradle Files

Customizing the Package Templates

Resources

Custom Java Code

Assets

Android Libraries

Building the Android Application

Desktop Entry Specification

Desktop Integration

Useful Classes

Opening External Resources

System Tray Icons

Desktop Widgets

Developing on Raspberry Pi

1. Download QBSP

2. Run the maintenance tool

3. Open Qt Creator

Development Tools

Qt Creator

Design Tools

Collaboration with Designers

Build Tools

Configuring and Building Qt

Internationalization and Help 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

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

Enterprise Qt Debian Packages

Debian Repository Configuration Format

Installing Public GPG Key

Configuring Authentication

Updating Local Package Cache

Full Configuration Example

Troubleshooting

Difficulties in authentication

401 Unauthorized

403 Forbidden

429 Too Many Requests

500 Internal Server Error

Difficulties with repository GPG key usage

Repository information for Qt Releases

Qt 6.3.2

Qt 6.3.1

Examples in Qt Automotive Suite

Exception Safety

Exception Safe Modules

Containers

Out of Memory Handling

Recovering from Exceptions

Exceptions in Client Code

Signals and Slots

Explore Qt

Reference Documentation

Participate in the Qt Community

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

Flashing and Running an Image on the 8155P

Qualcomm Snapdragon 8155P Board

Set up the wiring

Switch to Fastboot Mode

Flash images

Run Qt application on the board

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

Get and Install Qt

1. Create a Qt Account

2. Download the Installer

3. Install Qt

Updating or Removing Components

Getting Help

4. Create Applications

Additional Resources

Getting Started Programming with Qt Quick

Creating the Alarms Project

Qt Creator

Additional source files

qtquickcontrols2<@op>.</@op>conf

main<@op>.</@op>qml

AlarmDialog<@op>.</@op>qml

AlarmDelegate<@op>.</@op>qml

AlarmModel<@op>.</@op>qml

TumblerDelegate.qml

Entering new alarms

Editing alarms

Deleting alarms

Summary

Getting Started with Qt

Getting Started with Qt for Android

emulator dependencies

Android Development Prerequisites

Manually Installing the Prerequisites

Java Development Kit (JDK)

Android SDK Command Line Tools

Android SDK

Android NDK

Emulator

Platform Specific Configurations

Windows

Linux

Testing Your Setup

Getting Started with Qt for WebAssembly

Getting the source code

Glossary Of QML Terms

Common Terms

GnuWin32 Project

Google Pixel 6 Pro

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

Gradle

Graphics

Graphics in Qt Quick

Choosing a Rendering Path

3D Graphics with Qt Quick 3D

Shader Effects

High-Level Graphics with Qt GUI

Qt OpenGL Module

Printing

Images

HTML 4

HTML 5

HTML5 Web Database API

High DPI

Conceptual Model

Drawing

Image Assets

Device Independent Screen Geometry

Configuring

Platform Details

Configuring X11

Configuring Windows

Testing

QT_SCALE_FACTOR

DprGadget

Environment Variable Reference

Coordinate Systems Reference

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

Importing Static Plugins in CMake

Importing Static Plugins in qmake

Creating Static Plugins

Deploying and Debugging Plugins

How to Report a Bug

How to compress data with Qt?

ICU

IDC - The Interface Description Compiler (ActiveQt)

Icon Themes Specification

In-App purchasing demo

What is this demo?

3rd party app stores

How does the demo work

In-App purchases

Licenses and attributions

Including header moc files in sources

Inheritance Hierarchy

Inputs on an Embedded Linux Device

Use libinput

Input on eglfs and linuxfb without libinput

Mouse

Keyboard

Touch

Pen-based Tablets

Debug Input Devices

Use Custom Mouse Cursor Images

Install Qt Design Studio

Installing Platform Dependencies

Inter-Process Communication in Qt

TCP/IP

Local Server/Socket

Shared Memory

D-Bus protocol

QProcess Class

Session Management

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

Introduction to Qt

Designing User Interfaces

Cross-Platform

Features and APIs

Tools

Programming Languages

Where To Go From Here

JUnit XML

Java SE Development Kit

JavaScript Guide

JavaScript Reserved Words

JavaScript Resources

KDE

KDE applications

Khronos OpenGL ES API Registry

Known Issues

LLVM Attribution

Layout Examples

License Changes

Qt 6.4.3

Qt Core Module

Qt GUI Module

Qt Image Formats

Qt SQL Module

Qt 6.4.2

Qt Core Module

Qt GUI Module

Qt 6.4.1

Qt GUI Module

Qt Testlib Module

Qt Tools Module

Qt 6.4.0

Qt Core Module

Qt Imageformats Module

Qt Network Module

Qt Multimedia Module

Qt Quick3D Module

Qt Quick3DPhysics Module

Qt Tools Module

Qt Wayland Module

Qt 6.3.2

Qt GUI Module

Qt SQL Module

Qt 6.3.1

Qt Core Module

Qt GUI Module

Qt 6.3.0

Qt Core Module

Qt GUI Module

Qt Imageformats Module

Qt Quick3D Module

Qt Wayland Compositor Module

Qt 6.2.4

Qt Core Module

Qt SQL Module

Qt Testlib Module

Qt 6.2.3

Qt SQL Module

Qt 6.2.2

Qt Core Module

Qt 6.2.1

Qt Core Module

Qt 6.2.0

Qt Core Module

Qt GUI Module

Qt Imageformats Module

Qt Positioning Module

Qt Quick3D Module

Qt Quick Controls Module

Qt SQL Module

Qt Wayland Compositor Module

Qt 6.1.2

Qt Core Module

Qt GUI Module

Qt Image Formats

Qt 6.1.1

Qt GUI Module

Qt Shadertools Module

Qt SQL Module

Qt 6.1.0

Qt 3D Module

Qt Core Module

Qt GUI Module

Qt Imageformats Module

Qt SQL Module

Qt Shadertools Module

Qt 6.0.1

Qt Core Module

Qt 6.0

Qt Core Module

Qt GUI Module

Qt 3D Module

Previous Qt Versions

License of Qt examples

Licenses Used in Qt

Third-Party Licenses Used in Qt

Linux Console Tools (LCT)

Livecoding video effects with Qt5

Mac OS X Aqua

Macros for Building with CMake

Managing Assets with Asset Catalogs

Mesa llvmpipe

Microsoft Active Accessibility Event Constants

MinGW

Mitigating Cross-site Scripting With HTTP-only Cookies

Mobile Development

Android

iOS

Tools for Mobile Development

Design Tools for Mobile

Mobile SVG Profiles

Motif Extension

Motorola MotoG 3rd

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

Inter-Process Communication

New Classes and Functions in Qt 6.0

New Classes and Functions in Qt 6.1

New Classes and Functions in Qt 6.2

New Classes and Functions in Qt 6.3

New Classes and Functions in Qt 6.4

New and Modified BSD Licenses

Ninja

NotoColorEmoji font

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

OpenGL Instanced Rendering

OpenGL Primitive Restart

OpenGL Registry

OpenGL glTF

OpenJDK

OpenSSL Configure Options

OpenSSL Source

OpenSSL Toolkit

OpenSSL for Android

OpenSSL: Build Setup Script

Overview of Qt's Undo Framework

Undo framework

Introduction

Classes

Concepts

Perl

Pimp my video

Pixel 3A

Pixel 4

Pixel 4A

Platform Notes - iOS

Info.plist

Deployment

Application bundles

Information Property List Files

Info.plist with CMake

Info.plist with QMake

Application Assets

Icons

Launch Screens and Launch Images

Launch Screens

Launch Images

Native Image Picker

Expressing Supported iOS Versions

Publishing to Apple App Store

Symbol visibility warnings

Product archiving issue with CMake

Porting C++ Applications to Qt 6 using Clazy checks

Clazy checks dedicated to Qt 6 porting

How to apply Clazy checks

If using qmake

If using CMake

How to apply Clazy checks within Qt Creator

A word of caution

Porting to Android

Porting to Qt 6

Disable use of C++ API deprecated in Qt 5.15

Check the Changes to the Modules

Test for Graphical Regressions

High-DPI

Use the Platform Integration APIs

Use Porting Tool

Further Reading

Porting to iOS

PostgreSQL MinGW/Native Windows

Professional CMake: A Practical Guide

Prototyping with the QML Runtime Tool

qml_runtime_tool

Pthreads Programming: A POSIX Standard for Better Multiprocessing

Public Qt Repository

Publishing to Google Play

Building the App

Uploading the App to Google Play Store

Publishing Single-ABI bundles

Python

QML Applications

What is QML?

What is Qt Quick?

Buttons, Menus, and other Controls

Qt Quick Projects

Code Samples and Demos

Advanced Application Development Topics

Related Topics

QML Coding Conventions

QML Object Declarations

Grouped Properties

Unqualified access

Required properties

Signal handlers

JavaScript Code

Related Information

QML Performance Considerations And Suggestions

Timing Considerations

Profiling

JavaScript Code

Type-Conversion

Resolving Properties

Property Bindings

Sequence tips

Value-Type tips

General Performance Tips

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

QNX Neutrino RTOS

QNX website

QTBUG-72086

QTBUG-78009

QTBUG-81461

Qbs Manual

Qt 3D Studio Manual

Qt 4.8 Reference Documentation

Qt 5.15

Qt 6 QML Book

Qt 6.4

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 Android Manifest File Configuration

android.app.lib_name

android.app.background_running

android.app.arguments

android.app.system_libs_prefix

Qt Project to Manifest Configuration

Qt Default Configuration

Qt Specific Meta-data

Meta-data in Services

Qt Permissions and Features

Style Extraction

Qt Manifest before 6.2 Release

Qt Bug Tracker

Qt Centre

Qt Cloud Services

Qt CoAP Examples

Qt Coding Style

Qt Configure Options

Configure Workflow

Source, Build, and Install Directories

Examples, Tests, and Tools

Build Configurations

Debug and Release Builds

Static and Shared Builds

CMake Generators

Modules and Features

Excluding Qt Modules

Including or Excluding Features

Third-Party Libraries

SSL

Cross-Compilation Options

Developer Builds

Specific Options for Platforms

Qt Creator Manual

Qt Creator: Acknowledgements

Qt Creator: Adding Compilers

Qt Creator: Adding Debuggers

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: Advanced Use

Qt Creator: All Topics

Qt Creator: Analyzing CPU Usage

Qt Creator: Analyzing Code

Qt Creator: Analyzing Code with Cppcheck

Qt Creator: Applying Refactoring Actions

Qt Creator: Beautifying Source Code

Qt Creator: Browsing Project Contents

Qt Creator: Build Systems

Qt Creator: Building Applications for the Web

Qt Creator: Building and Running

Qt Creator: Building and Running an Example

Qt Creator: Building and Running an Example

Qt Creator: Building for Multiple Platforms

Qt Creator: CMake Build Configuration

Qt Creator: Checking Code Syntax

Qt Creator: Coding

Qt Creator: Collecting Usage Statistics

Qt Creator: Comparing Files

Qt Creator: Completing Code

Qt Creator: Conan Build Configuration

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

Qt Creator: Connecting Devices

Qt Creator: Connecting Generic Remote Linux Devices

Qt Creator: Connecting MCUs

Qt Creator: Connecting QNX Devices

Qt Creator: Connecting iOS devices

Qt Creator: Converting UI Projects to Applications

Qt Creator: Creating C++ Classes

Qt Creator: Creating Projects

Qt Creator: Creating Qt Quick Projects

Qt Creator: Creating a Mobile Application

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 Generic Remote Linux Devices

Qt Creator: Deploying Applications to QNX Neutrino Devices

Qt Creator: Deploying to Devices

Qt Creator: Designing User Interfaces

Qt Creator: Desktop Platforms

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

Qt Creator: Editing State Charts

Qt Creator: Embedded Platforms

Qt Creator: FAQ

Qt Creator: File System

Qt Creator: Finding

Qt Creator: Finding and Replacing

Qt Creator: Getting Help

Qt Creator: Getting Started

Qt Creator: Glossary

Qt Creator: How-tos

Qt Creator: IDE Overview

Qt Creator: IncrediBuild Build Configuration

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 Android SDK Packages

Qt Creator: Managing Data Collection

Qt Creator: Managing Projects

Qt Creator: Managing Sessions

Qt Creator: Meson Build Configuration

Qt Creator: Mobile Platforms

Qt Creator: Modeling

Qt Creator: Open Documents

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: Previewing in Browsers

Qt Creator: Previewing on Desktop

Qt Creator: Previewing on Devices

Qt Creator: Profiling Function Execution

Qt Creator: Profiling QML Applications

Qt Creator: Profiling QML Applications

Qt Creator: Projects

Qt Creator: Qbs Build Configuration

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: Selecting Modes

Qt Creator: Semantic Highlighting

Qt Creator: Setting Up CMake

Qt Creator: Setting Up Conan

Qt Creator: Setting Up Debugger

Qt Creator: Setting Up IncrediBuild

Qt Creator: Setting Up Meson

Qt Creator: Setting Up Nimble

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: Signing Android Packages

Qt Creator: Specifying Android Device Settings

Qt Creator: Specifying Build Settings

Qt Creator: Specifying Code Style Settings

Qt Creator: Specifying Dependencies

Qt Creator: Specifying Editor Settings

Qt Creator: Specifying Environment Settings

Qt Creator: Specifying Run Settings

Qt Creator: Specifying Settings for Packages

Qt Creator: Specifying Text Editor Settings

Qt Creator: Supported Platforms

Qt Creator: Technical Support

Qt Creator: Testing

Qt Creator: Troubleshooting Debugger

Qt Creator: Tutorials

Qt Creator: UI Files

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 Custom Output Parsers

Qt Creator: Using Debugging Helpers

Qt Creator: Using External Tools

Qt Creator: Using FakeVim Mode

Qt Creator: Using Git

Qt Creator: Using Language Servers

Qt Creator: Using Mercurial

Qt Creator: Using Perforce

Qt Creator: Using QML Modules with Plugins

Qt Creator: Using Qt Quick Designer

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: Validating with Target Hardware

Qt Creator: Viewing Output

Qt Creator: Visualizing Chrome Trace Events

Qt Creator: Working in Edit Mode

Qt Creator: Working with Sidebars

Qt Creator: Writing Code

Qt Creator: qmake Build Configuration

Qt Design Studio Manual

Qt Design Studio Manual

Qt Design Studio: 2D Effects

Qt Design Studio: 3D Editor

Qt Design Studio: 3D Effects

Qt Design Studio: 3D Materials

Qt Design Studio: 3D Models

Qt Design Studio: 3D Views

Qt Design Studio: Acknowledgements

Qt Design Studio: Adding Action Areas and Transitions

Qt Design Studio: Adding Bindings Between Properties

Qt Design Studio: Adding Connections

Qt Design Studio: Adding Flow Items

Qt Design Studio: Adding Flow Views

Qt Design Studio: Adding States

Qt Design Studio: Advanced Designer Topics

Qt Design Studio: All Topics

Qt Design Studio: Animations

Qt Design Studio: Annotating Designs

Qt Design Studio: Applying Effects to Transitions

Qt Design Studio: Applying Refactoring Actions

Qt Design Studio: Applying States in Flows

Qt Design Studio: Asset Creation with Other Tools

Qt Design Studio: Browsing Project Contents

Qt Design Studio: Cameras

Qt Design Studio: Checking Code Syntax

Qt Design Studio: Coding

Qt Design Studio: Collecting Usage Statistics

Qt Design Studio: Collecting User Feedback

Qt Design Studio: Comparing Files

Qt Design Studio: Completing Code

Qt Design Studio: Components

Qt Design Studio: Concepts and Terms

Qt Design Studio: Configuring the Editor

Qt Design Studio: Connecting Components to Signals

Qt Design Studio: Connection View

Qt Design Studio: Converting Qt 5 Projects into Qt 6 Projects

Qt Design Studio: Converting UI Projects to Applications

Qt Design Studio: Creating Buttons

Qt Design Studio: Creating Component Instances

Qt Design Studio: Creating Custom Components

Qt Design Studio: Creating Optimized 3D Scenes

Qt Design Studio: Creating Projects

Qt Design Studio: Creating Scalable Buttons and Borders

Qt Design Studio: Creating Timeline Animations

Qt Design Studio: Creating UI Logic

Qt Design Studio: Curve Editor

Qt Design Studio: Custom Effects and Materials

Qt Design Studio: Custom Shaders

Qt Design Studio: Debugging Qt Quick Projects

Qt Design Studio: Debugging a Qt Quick Example Application

Qt Design Studio: Debugging and Profiling

Qt Design Studio: Design Views

Qt Design Studio: Designing Application Flows

Qt Design Studio: Developer Topics

Qt Design Studio: Dynamic Behaviors

Qt Design Studio: Editing Easing Curves

Qt Design Studio: Examples and Tutorials

Qt Design Studio: Exporting 3D Assets

Qt Design Studio: Exporting Components

Qt Design Studio: Exporting Designs from Adobe Illustrator

Qt Design Studio: Exporting Designs from Adobe Photoshop

Qt Design Studio: Exporting Designs from Adobe XD

Qt Design Studio: Exporting Designs from Figma

Qt Design Studio: Exporting Designs from Sketch

Qt Design Studio: Exporting from Blender

Qt Design Studio: Exporting from Design Tools

Qt Design Studio: Exporting from Maya

Qt Design Studio: Exporting from Qt 3D Studio

Qt Design Studio: File System

Qt Design Studio: Finding

Qt Design Studio: Finding and Replacing

Qt Design Studio: Form Editor

Qt Design Studio: Frequently Asked Questions

Qt Design Studio: Getting Started

Qt Design Studio: Group

Qt Design Studio: Help

Qt Design Studio: Images

Qt Design Studio: Implementing Applications

Qt Design Studio: Importing 2D Assets

Qt Design Studio: Importing 3D Assets

Qt Design Studio: Importing Designs

Qt Design Studio: Indenting Text or Code

Qt Design Studio: Installation

Qt Design Studio: Instanced Rendering

Qt Design Studio: Introduction to Animation Techniques

Qt Design Studio: Keyboard Shortcuts

Qt Design Studio: Library

Qt Design Studio: Lights

Qt Design Studio: Lists and Other Data Models

Qt Design Studio: Loader3D

Qt Design Studio: Loading Placeholder Data

Qt Design Studio: Log In UI - Components

Qt Design Studio: Log In UI - Positioning

Qt Design Studio: Log In UI - States

Qt Design Studio: Log In UI - Timeline

Qt Design Studio: Logic Helpers

Qt Design Studio: Managing Data Collection

Qt Design Studio: Managing Sessions

Qt Design Studio: Managing Workspaces

Qt Design Studio: Materials and Shaders

Qt Design Studio: Morph Target

Qt Design Studio: Motion Design

Qt Design Studio: Navigator

Qt Design Studio: Node

Qt Design Studio: Open Documents

Qt Design Studio: Optimizing Designs

Qt Design Studio: Packaging Applications

Qt Design Studio: Preset Components

Qt Design Studio: Previewing in Browsers

Qt Design Studio: Previewing on Desktop

Qt Design Studio: Previewing on Devices

Qt Design Studio: Production Quality

Qt Design Studio: Profiling QML Applications

Qt Design Studio: Projects

Qt Design Studio: Properties

Qt Design Studio: Prototyping

Qt Design Studio: Reacting to External Events

Qt Design Studio: Refactoring

Qt Design Studio: Repeater3D

Qt Design Studio: Reporting Crashes

Qt Design Studio: Scalable Layouts

Qt Design Studio: Scene Environment

Qt Design Studio: Searching with the Locator

Qt Design Studio: Selecting Modes

Qt Design Studio: Semantic Highlighting

Qt Design Studio: Setting Up Qt Bridge for Adobe Photoshop

Qt Design Studio: Setting Up Qt Bridge for Adobe XD

Qt Design Studio: Setting Up Qt Bridge for Figma

Qt Design Studio: Setting Up Qt Bridge for Sketch

Qt Design Studio: Shapes

Qt Design Studio: Simulating Application Logic

Qt Design Studio: Simulating Complex Experiences

Qt Design Studio: Simulating Conditions

Qt Design Studio: Simulating Dynamic Systems

Qt Design Studio: Simulating Events

Qt Design Studio: Skeletal Animation

Qt Design Studio: Specifying Component Properties

Qt Design Studio: Specifying Dynamic Properties

Qt Design Studio: Specifying Editor Settings

Qt Design Studio: Specifying Text Editor Settings

Qt Design Studio: States

Qt Design Studio: Supported Platforms

Qt Design Studio: Technical Support

Qt Design Studio: Text

Qt Design Studio: Text Editor

Qt Design Studio: Textures

Qt Design Studio: Timeline

Qt Design Studio: Transition Editor

Qt Design Studio: Tutorials

Qt Design Studio: UI Controls

Qt Design Studio: UI Files

Qt Design Studio: Use Cases

Qt Design Studio: User Interaction Methods

Qt Design Studio: User Interface

Qt Design Studio: Using Custom Fonts

Qt Design Studio: Using External Tools

Qt Design Studio: Using Git

Qt Design Studio: Using QML Modules with Plugins

Qt Design Studio: Using Qt Bridge for Adobe Photoshop

Qt Design Studio: Using Qt Bridge for Adobe XD

Qt Design Studio: Using Qt Bridge for Figma

Qt Design Studio: Using Qt Bridge for Sketch

Qt Design Studio: Using Qt Quick Toolbars

Qt Design Studio: Using the Help Mode

Qt Design Studio: Validating with Target Hardware

Qt Design Studio: Viewing Output

Qt Design Studio: Washing Machine UI

Qt Design Studio: Wireframing

Qt Design Studio: Working in Edit Mode

Qt Design Studio: Working with Sidebars

Qt Design Studio: Writing Code

Qt Design Studio: Your First UI

Qt Downloads

Qt Edu for Designers

1. Apply for Qt Educational license

Create a password

2. Verify email address

3. Download the online installer

4. Run the installer

5. Log in to Qt Account

Notes about build environment

6. Contribute to Qt development

7. Select installation folder

8. License agreements

9. Finish the installation

10. Open Qt Design Studio

Qt Edu for Developers

1. Apply for Qt Educational license

Create a password

2. Verify email address

3. Download the online installer

4. Run the installer

5. Log in to Qt Account

Notes about build environment

6. Contribute to Qt development

7. Select installation folder

8. License agreements

9. Finish the installation

10. Open Qt Creator

Qt Edu resources

Information about Qt Account

Useful links

Qt Educational License

Qt Examples And Tutorials

Running the Examples

Community Examples

All Examples

Qt FTP

Qt Features

Qt HTTP

Qt Homepage

Qt KNX Examples

Qt Licensing

Purchasing and Sales Information

Licensed Code in Qt

Qt Licensing Overview

Qt Licensing Overview

Qt MQTT Examples

Qt Marketplace

Qt Marketplace License Agreement

Qt Multimedia Backends

Qt OPC UA Examples

Qt Overviews

Best Practices

Reference

Qt Packaging Recommendations

Qt Quarterly

Qt Quarterly: Another Look at Events

Qt Quarterly: Plural Form in Translation

Qt Quick Compiler

Qt Quick Demo - Calqlatr

Running the Example

Displaying Custom Components

Animating Components

Performing Calculations

List of Files

Qt Quick Demo - Clocks

Running the Example

Displaying Data Generated by List Models

Qt Quick Demo - Photo Surface

Running the Example

Creating the Main Window

Accessing Folder Contents

Displaying Images on the Photo Surface

Handling Pinch Gestures

Qt Quick Demo - Photo Viewer

Running the Example

Using Custom Types

Creating the Main Window

Displaying Photos

Downloading Flickr Feeds

Creating Flipable Labels

Laying Out Photos on a Path

Providing Feedback to Users

Localizing Applications

Qt Quick Demo - RESTful API client Address Book

Qt Quick Demo - RSS News

Running the Example

Using Custom Types

Creating the Main Window

Creating a Category List

Creating List Elements

Downloading XML Data

Providing Feedback to Users

Creating Scroll Bars

Creating Footers

Creating Buttons

Qt Quick Demo - StocQt

Running the Example

Qt Quick Enterprise Controls

Qt Quick Ultralite Examples

Qt Reference Pages

Class Lists

Function Lists

QML Reference

Qt Tool Manuals

Commercial Only Modules

Platform Reference

Qt VS Tools

Qt VS Tools Manual

Qt WebKit

Qt WebKit Widgets

Qt and WebAssembly

Qt for Android

Supported Configurations

Where to Go from Here

Qt for Android - Building User Projects

Building with CMake

Building multi-ABI packages using CMake

Building with qmake

Qt for Android - Building from Source

Prerequisites

Windows

Getting the Sources

Configuring

Architectures

Advanced Configure Arguments

Building

Installing

Qt for Android Automotive

Qt for Android Automotive

Qt for Android Automotive

Qt for Android Automotive Quick Starter Guide

Qt for Android Examples

Running the Examples

Essentials

Qt Quick and QML Examples for Android

Qt for Automation

Qt for Education

Qt for Embedded Linux

embedded eglfs

Platform plugins for embedded Linux devices

EGLFS

Environment variables used by EGLFS

Logging

LinuxFB

Specifying additional settings

Display output

EGLFS with the eglfs_kms backend

Custom configuration

Default behavior

Automatic physic screen size querying

Active outputs and QScreen instances

A common use case

Advanced eglfs_kms features

Cloning (mirroring)

Headless mode using DRM render

DRM API selection

EGLFS with an 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

Performance enhancement guidelines

Use hardware rendering where possible

Follow the best practices for Qt Quick

Use images/textures and shader effects instead of the Canvas QML type

Use Qt Quick instead of Qt Widgets

Choose a resolution appropriate for your UI size

Use a QML Window type as your application's root element

Related topics

Qt for Embedded Linux Fonts

FreeType

QPF2

FreeType Formats

Qt Prerendered Font (QPF2)

Qt for INTEGRITY

INTEGRITY

Supported Qt Modules

Supported Development Hosts and Target Boards

Qt for INTEGRITY - Monolith Project Tutorial

Qt for Linux/X11

Supported Configurations

Requirements for Development Host

Debian/Ubuntu (apt-get)

Fedora/RHEL/CentOS (yum)

openSUSE (zypper)

Building Qt from Source

Deployment and Other Issues

Where to Go from Here

Qt for Linux/X11 - Building from Source

Step 1: Unpacking the Archive

Step 2: Build the Qt Library

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

Qt for MCUs

Qt for Python

Qt for Python Examples

Qt for Python Tutorials

Qt for QNX

QNX

Qt for QNX 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

Qt for QNX Support

QNX releases and architectures

Previous releases

Target hardware

Supported Qt modules

Host systems

Qt for WebAssembly

Getting Started with Qt for WebAssembly

Installing Emscripten

Installing Qt

Building Qt from Source

Building Applications on the Command Line

Running Applications

Emrun

Python http.server

qtwasmserver

Building Applications using Qt Creator

Deploying Applications on the web

Supported Browsers

Desktop

Mobile

Supported Qt Modules

Developing with Qt for WebAssembly

OpenGL and WebGL

Multithreading

SIMD

Networking

Local File Access

Clipboard Access

Fonts

Application Startup and the Event Loop

Asyncify

Debugging and Profiling

Asyncify

Known Issues

Other Topics

Qt Configure Options Reference

Typical Download Sizes

Examples

External resources

License

Qt for WebAssembly Technology Preview

Qt for WebAssembly wiki

Qt for Windows

Supported Configurations

Building from Source

Deployment and Other Issues

Where to Go from Here

Visual Studio Tools

Qt for Windows - Building from Source

Step 1: Getting the Sources

Step 2: Install Build Requirements

Build Tools

Compilers

QDoc Dependencies

Step 3: Set the Environment Variables

Step 4: Build the Qt Library

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

Ensuring Plugins Are Found when Using Non-Relocatable Builds

Qt for Windows - Graphics Acceleration

Dynamically Loading OpenGL

Direct dependency to opengl32.dll

Qt for Windows - Specific Issues

Installation location

Maximum path length

Visual Studio

Fullscreen OpenGL Based Windows

Qt for X11 Requirements

Platform Plugin Dependencies

Accessibility Dependencies

OpenGL Dependencies

QDoc Dependencies

Qt for iOS

Supported Configurations

Getting Started

Setting Up the Development Environment

Building Applications from the Command Line

Using CMake

Using qmake

Customizing Xcode project settings

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 macOS

Supported Versions

Build Environment

Target Platforms

Opting out of macOS behavior changes

Architectures

Generating Xcode Project Files

Deploying Applications on macOS

Using Objective-C Code in Qt Applications

macOS Issues

Where to Go from Here

Qt for macOS - Building from Source

Requirements

QDoc Dependencies

Steps for Building

Step 1: Unpack the Archive

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

Using CMake

Using qmake

Checking linked libraries

Frameworks

Building Qt as Frameworks

Linking the Application to Qt as Frameworks

Using CMake

Using qmake

Creating the Application Package

Application Dependencies

Qt Plugins

Additional Libraries

The Mac Deployment Tool

Volume Name

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

Using Native Cocoa Panels

Limitations

MySQL and macOS

D-Bus and macOS

Menu Actions

Native Widgets

Symbol visibility warnings

Qt for webOS

Developing Applications with Qt for webOS

Supported Platforms and Versions

Further Reading

Qt pricing

QtMediaHub

QtonPi

RFC 1036

RFC 1179

RFC 1738

RFC 1918

RFC 1928

RFC 1929

RFC 2045

RFC 2109

RFC 2822

RFC 2965

RFC 3174

RFC 3491

RFC 3492

RFC 3986

RFC 4122

RFC 4627

RFC 4648

RFC 4686

RFC 5280, section 5.3.1

RFC 6347

RFC 6347, section 4.2.1

RFC 6347, section 4.2.8

RFC 6724

RFC 7049

RFC 7049, section 3.10

RFC 7049, section 3.9

RFC 7049, section 6

RFC 7252

RFC 8018, section 5.1

RFC 8018, section 5.2

RFC 8152

RFC 8446, section 6

RFC 850

Reentrancy and Thread-Safety

Reentrancy

Thread-Safety

Notes on Qt Classes

Registering Products in App Store

Register a unique app ID

Create a provisioning profile

Register your application

Archive and uploading application

Setting up application testing

Register the products

Registering Products in Google Play

Preparing your application for submission

Adding a Manifest XML

Signing the application

Registering your application

Publishing your application

Adding in-app products

Remote UIs with WebGL and WebAssembly

Resource Compiler (rcc)

Restoring a Window's Geometry

SIL OPEN FONT LICENSE

SQL Examples

SVG 1.2 Tiny

SVG 1.2 Tiny Static Features

SVG Working Group

SVG color keyword names

Sailfish OS

Samsung Galaxy S10

Samsung Galaxy S21

Samsung Galaxy Tab S4

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

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

Using CMake on Windows

Using qmake on Windows

Setting the Application Icon on macOS

Using CMake on macOS

Using qmake on macOS

Setting the Application Icon on Common Linux Desktops

K Desktop Environment (KDE)

GNOME

Solutions for Application Development

Solutions for UI Design

Specifying Your App's Launch Screen

Standard Accelerator Keys

Standard CSS2 selector

State Chart XML: State Machine Notation for Control Abstraction

Statecharts: A visual formalism for complex systems

Sun Studio Patches

Supported Platforms

Desktop Platforms

Linux/X11

macOS

Windows

Mobile Platforms

Android

iOS

WebAssembly (Technology Preview)

Embedded Platforms

Android Automotive OS

webOS OSE

Embedded Linux

Real Time Operating Systems

Web Platforms

WebAssembly

Availability of Packages

Exceptions

Deployment of Qt Applications

Supported Qt Versions

General Legal Disclaimer

Supporting Google Emoji Font Policy

Bundling an Emoji Font VS Google Downloadable Fonts

How to bundle a font

Obtaining a Font

Adding the Font

Loading the bundled font in C++

Loading the bundled font in QML

Using Google downloadable fonts:

Configuration

Customizing the Android packages template

Adding AndroidX

Adding Font Provider Certificates

Java Code

C++ Code

Synchronizing Threads

Low-Level Synchronization Primitives

Risks

Convenience classes

High-Level Event Queues

TDM-GCC

TeamCity

Test Anything Protocol

Test Center

Testing and Debugging

Unit Testing

Autotests

Testing with Qt Creator

Debugging Techniques

The Chromium Projects

The K Desktop Environment

KDE

The LLDB Debugger

The Qt Company

The QtEntryPoint Library

QtEntryPoint

License Information

Third Party Libraries

Source Code

Library Files

Destination Directory

Third-party Android Libraries

Prerequisites

Including a Library to an Android Project

Adding a .jar or .aar Library

Adding a Library Project

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

Tools for Qt Quick UIs

Tools for Qt Widget-Based UIs

Trademarks

Trafikanten

Translation Rules for Plurals

Tutorial: Deploying Your First Project with Boot to Qt

Unicode in Qt

Unicode

Qt's Classes for Working with Strings

Information about Unicode on the Web

Unicode in Qt

Unicode standard

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

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

Building UIs with Qt Quick

Qt Widgets User Interfaces

Comparison of UI Interfaces

Related Topics

Using qt.conf

Format and Location

Overriding Paths

Configuring Arguments to the Platform Plugins

How to deal with parallel installations of older Qt versions

Using the Meta-Object Compiler (moc)

Usage

Writing Make Rules for Invoking moc

Command-Line Options

Diagnostics

Build Systems

Including header moc files

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

Wayland and Qt

What is a Display Server

The Role of Wayland

Wayland and Other Technology

Extensibility and Embedded Systems

Multi-Process or Single-Process

Benefits of Multi-Process

Trade-offs of Multi-Process

Why Use Wayland Instead of X11 or Custom Solutions

What Qt Wayland Offers

Related Content

WebAssembly Resource site

WebKit Open Source Project

What's New in Qt 6.0

Build System Changes in Qt 6

Changes to Supported Modules

New Modules in Qt 6.0

Removed Modules in Qt 6.0

List of API Changes

What's New in Qt 6.1

New and Restored Modules in Qt 6.1

Active Qt Module

Qt Charts Module

Qt Data Visualization Module

Qt Device Utilities Module

Qt Lottie Module

Qt SCXML and Qt StateMachine

Qt Virtual Keyboard Module

New Features in Qt 6.1

Qt Core Module

Qt Gui Module

Qt Widgets Module

Qt Network Module

Qt Qml Module

Qt Quick 3D Module

Qt 5 Compatibility Module

List of API Changes

What's New in Qt 6.2

New and Restored Modules in Qt 6.2

New Features in Qt 6.2

Qt Core Module

Qt GUI Module

Qt Quick Module

Qt Quick Controls Module

Qt Widgets Module

Qt Network Module

Qt QML Module

Qt Quick 3D Module

Qt Data Visualization Module

Qt Charts Module

Qt for Python

Platform Changes

Technology Preview Platforms

Windows on ARM

Desktop Platforms

macOS on Apple Silicon

Wayland Client on Linux

Mobile Platforms

Android

iOS

Embedded Platforms

Boot to Qt

QNX

INTEGRITY

WebOS

List of API Changes

What's New in Qt 6.3

New and Restored Modules in Qt 6.3

New Features in Qt 6.3

Qt Core Module

Qt GUI Module

Qt Quick Module

Qt Quick Controls Module

Qt Quick Dialogs Module

Qt Widgets Module

Qt Network Module

Qt QML Module

Qt Quick 3D Module

Qt WebEngine Module

Qt Data Visualization Module

Qt Positioning Module

Qt Bluetooth Module

Qt Wayland Compositor Module

Platform Changes

Technology Preview Platforms

WebAssembly

Windows on ARM

Mobile Platforms

Android

iOS

Embedded Platforms

Boot to Qt

Other

Wayland

List of API Changes

Additions to All Qt 6 Releases

What's New in Qt 6.4

New and Restored Modules in Qt 6.4

New Features in Qt 6.4

Qt Core Module

Qt GUI Module

Qt Quick Module

Qt Quick Controls Module

Qt Quick Dialogs Module

Qt Widgets Module

Qt Network Module

Qt Test Module

Qt QML Module

Qt Quick 3D Module

Qt Connectivity Module

Qt WebEngine Module

Platform Changes

WebAssembly

Mobile Platforms

Android

Embedded Platforms

Boot to Qt

QNX

WebOS

List of API Changes

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

Winsock 2 Socket Handle

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

X.org

XEmbed Specification

XML Bookmark Exchange Language Resource Page

XML Examples

XML Schema

XaoS

Xcode

Yocto Project

Zstandard Site

error handling in the XQuery language

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

iOS: Defining a Custom URL Scheme for Your App

iOS: Supporting Associated Domains

iOS: canOpenURL:

iTunes: Flyingbus

iTunes: Qt Hangman

iTunes: QtQuicksand

iTunes: Quick Forecast

iTunes: SubAttack

jom

kmap2qmap

libinput

libusb

makeqpf

publicsuffix.org

qsslkey example

qtestlib-tools

testcon - An ActiveX Test Container (ActiveQt)

Accessibility Classes

Accessibility for Qt Quick Applications

Introduction

Adding Accessibility Metadata to QML Items

Related Classes and Interfaces

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

Locating Qt Translations

Available Catalogs

Example: Basic Qt Modules

Support for Encodings

Localizing Numbers, Dates, Times and Currency

Dynamic Translation

System Support

Unix/X11

Linux

Windows

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

What's new in Qt 6

New Classes and Functions

Qt XML Examples