Qt Core Reference Documentation

Contiguous Cache Example

Custom Type Example

Overview

The Message Class Definition

The Message Class Implementation

Using the Message

Further Reading

JSON Save Game Example

The Character Class

Local Fortune Client Example

Local Fortune Server Example

MIME Type Browser Example

Running the Example

Main Window

Mandelbrot Example

RenderThread Class Definition

RenderThread Class Implementation

MandelbrotWidget Class Definition

MandelbrotWidget Class Implementation

The main() Function

Subclassing

Subclassing

Subclassing

The Event Loop and Event Handling

Application and Library Paths

Internationalization and Translations

Accessing Command Line Arguments

Locale Settings

Reference Clocks

Timer types

std<@op>::</@op>chrono Compatibility

Basic Use

Formatting Options

Writing Custom Types to a Stream

Navigation and Directory Operations

Files and Directory Contents

The Current Directory and Other Special Paths

Path Manipulation and Strings

Examples

Reference Clocks

32-bit overflows

Reading Files Directly

Using Streams to Read Files

Signals

Platform Specific Issues

NTFS permissions

Performance Issues

Using QFileSelector

Adding Selectors

Conflict Resolution when Multiple Selectors Apply

Creating Category Objects

Checking Category Configuration

Default Category Configuration

Configuring Categories

Logging Rules

Installing a Custom Filter

Printing the Category

Property Meta-Data

Copying and Assignment

Platform-Specific MIME Types

No copy constructor

Thread Affinity

No Copy Constructor or Assignment Operator

Auto-Connection

Dynamic Properties

Internationalization (I18n)

Running a Process

Communicating via Channels

Synchronous Process API

Notes for Windows Users

Dynamic Resource Loading

Basic Usage

QVariant and GUI Types

Section and Key Syntax

Fallback Mechanism

Restoring the State of a GUI Application

Accessing Settings from Multiple Threads or Processes Simultaneously

Platform-Specific Notes

Locations Where Application Settings Are Stored

Accessing INI and .plist Files Directly

Accessing the Windows Registry Directly

Accessing Common Registry Settings on Windows

Platform Limitations

write notifiers

Sorting

Filtering

Subclassing

Platform-Specific Behavior

Creating Your Own Codec Class

Accuracy and Timer Resolution

Alternatives to QTimer

Looking up Translations

Using Multiple Translations

Relative URLs vs Relative Paths

Error checking

Character Conversions

Encoding

Handling of spaces and plus ("+")

Full decoding

Non-standard delimiters

Variant field

Version field

A Note on GUI Types

Using canConvert() and convert() Consecutively

Queued Custom Type Example

Overview

The Block Class

The Window Class

The RenderThread Class

Registering the Type

Further Reading

Semaphores Example

Global Variables

Producer Class

Consumer Class

The main() Function

Shared Memory Example

Wait Conditions Example

Global Variables

Producer Class

Consumer Class

The main() Function

Serializing Qt Classes

Versioning

Reading and Writing Raw Binary Data

Reading and Writing Qt Collection Classes

Reading and Writing Other Qt Classes

Using Read Transactions

QJsonValueRef

Subclassing

Subclassing

The Atomic API

Reference counting

Memory ordering

Test-and-set

Fetch-and-store

Fetch-and-add

Feature Tests for the Atomic API

The Atomic API

Memory ordering

Test-and-set

Fetch-and-store

Fetch-and-add

Feature Tests for the Atomic API

Notes on Locale

Number-String Conversions

8-bit Character Comparisons

Subclassing

How to Use QCommandLineParser in Complex Applications

Remarks

No Year 0

Range of Valid Dates

Remarks

No Year 0

Range of Valid Dates

Use of System Timezone

Daylight-Saving Time (DST)

Offset From UTC

Time Zone Support

qHash

The qHash() hashing function

Algorithmic complexity attacks

Constraints

More Members

More Information on Using Qt Containers

16-bit Floating Point Support

Generic Algorithms

Types of Iterators

Input Iterators

Output Iterators

Forward Iterators

Bidirectional Iterators

Random Access Iterators

Qt and the STL Algorithms

Porting guidelines

Endian Conversion Functions

Global Qt Declarations

Types

Functions

Macros

Generic Math Functions

Defining Plugins

Big5 Text Codec

Big5-HKSCS Text Codec

Container Classes

assignable data type

assignable data types

default-constructed value

constant time

logarithmic time

linear time

linear-logarithmic time

quadratic time

container class

container classes

Introduction

The Container Classes

The Iterator Classes

Java-Style Iterators

STL-Style Iterators

Implicit sharing iterator problem

The foreach Keyword

Other Container-Like Classes

Algorithmic Complexity

Growth Strategies

Creating Custom Qt Types

Overview

Creating a Custom Type

Declaring the Type with QMetaType

Creating and Destroying Custom Objects

Making the Type Printable

Further Reading

Data Compression Library (zlib)

EUC-JP Text Codec

EUC-KR Text Codec

Easing Equations by Robert Penner

Efficient Binary-Decimal and Decimal-Binary Conversion Routines for IEEE Doubles

File and Datastream Functions

FreeBSD strtoll and strtoull

GBK Text Codec

Gradle wrapper

IANA character-sets encoding file

ISO 2022-JP (JIS) Text Codec

ISO 8601

Implicit Sharing

deep copy

shallow copy

implicitly shared classes

implicit data sharing

implicit sharing

implicitly shared

reference counting

shared implicitly

shared classes

Overview

Implicit Sharing in Detail

List of Classes

MD4

MD5

Object Model

Identity vs Value

Important Classes

Qt Objects: Identity vs Value

Object Trees & Ownership

note on the order of construction/destruction of QObjects

Overview

Construction/Destruction Order of QObjects

PCRE2

PCRE2 - Stack-less Just-In-Time Compiler

Pros and Cons of Using QList

QEventDispatcher on macOS

qeventdispatcher_cf

Flags and the Meta-Object System

Naming Convention

library location

Rendering

Coordinates

Constraints

Rendering

Coordinates

capturing parentheses

greedy quantifiers

cap_in_a_loop

QRegExp wildcard matching

regular expression

Introduction

Characters and Abbreviations for Sets of Characters

Sets of Characters

Quantifiers

Capturing Text

Assertions

Wildcard Matching

Notes for Perl Users

Code Examples

normal matching

extracting captured substrings

global matching

partial matching

validating user input

regular expression

Introduction

Pattern Options

Match Type and Match Options

Normal Matching

Extracting captured substrings

Global Matching

Partial Matching

Validating user input

Incremental/multi-segment matching

Error Handling

Unsupported Perl-compatible Regular Expressions Features

Notes for QRegExp Users

Porting from QRegExp::exactMatch()

Porting from QRegExp's Exact Matching

Porting from QRegExp's Partial Matching

Global matching

Unicode properties support

Wildcard matching

Other pattern syntaxes

Minimal matching

Caret modes

Debugging Code that Uses QRegularExpression

regular expression match

regular expression iterator

Seeding and determinism

Bulk data

System-wide random number generator

Fallback quality

Reentrancy and thread-safety

Standard C++ Library compatibility

Custom Cleanup Handlers

Forward Declared Pointers

Employee example

Implicit vs Explicit Sharing

Implicit vs Explicit Sharing

Optimize Performance for Usage in Qt Containers

Thread-Safety

Other Pointer Classes

Optional Pointer Tracking

States with Child States

Initializing a String

Manipulating String Data

Querying String Data

Converting Between 8-Bit Strings and Unicode Strings

Distinction Between Null and Empty Strings

Argument Formats

More Efficient String Construction

Unicode Handling

Unchecked Iteration

Initializing

Adding Strings

Iterating Over the Strings

Manipulating the Strings

QTextStream manipulators

Managing Threads

Caveats

Remarks

IANA Time Zone IDs

UTC Offset Time Zones

Windows Time Zones

System Time Zone

Time Zone Offsets

License

More Information on Using Qt Containers

Namespaces

Incremental Parsing

Performance and Memory Consumption

Qt Core

Getting Started

Core Functionalities

Threading and Concurrent Programming

Input/Output, Resources, and Containers

Additional Frameworks

Licenses and Attributions

Reference

RFC 4648

Secure Hash Algorithm SHA-1

Secure Hash Algorithm SHA-3 - Keccak

sha3_keccak

Secure Hash Algorithm SHA-3 - brg_endian

sha3_endian

Secure Hash Algorithms SHA-384 and SHA-512

Serializing Qt Data Types

Shift-JIS Text Codec

Signals & Slots

3rd Party Signals and Slots

Signals and Slots

Introduction

Signals and Slots

Signals

Slots

A Small Example

A Real Example

Signals And Slots With Default Arguments

Advanced Signals and Slots Usage

Using Qt with 3rd Party Signals and Slots

TSCII Text Codec

Text Codec: EUC-JP

Text Codec: EUC-KR

Text Codec: GBK

Text Codec: ISO 2022-JP (JIS)

Text Codec: Shift-JIS

Text Codec: TSCII

Text Codecs: Big5, Big5-HKSCS

The Animation Framework

Animation

The Animation Architecture

Classes in the Animation Framework

Animating Qt Properties

Animations and the Graphics View Framework

Easing Curves

Putting Animations Together

Animations and States

The Event System

How Events are Delivered

Event Types

Event Handlers

Event Filters

Sending Events

The Meta-Object System

Meta-Object System

The Property System

Qt's Property System

Requirements for Declaring Properties

Reading and Writing Properties with the Meta-Object System

A Simple Example

Dynamic Properties

Properties and Custom Types

Adding Additional Information to a Class

The Public Suffix List

The Qt Resource System

resource system

Resource Collection Files (<@op>.</@op>qrc)

External Binary Resources

Compiled-In Resources

Compression

Using Resources in the Application

Using Resources in a Library

The State Machine Framework

Classes in the State Machine Framework

A Simple State Machine

Doing Useful Work on State Entry and Exit

State Machines That Finish

Sharing Transitions By Grouping States

Using History States to Save and Restore the Current State

Using Parallel States to Avoid a Combinatorial Explosion of States

Detecting that a Composite State has Finished

Targetless Transitions

Events, Transitions and Guards

Using Restore Policy To Automatically Restore Properties

Animating Property Assignments

Detecting That All Properties Have Been Set In A State

What Happens If A State Is Exited Before The Animation Has Finished

Default Animations

Nesting State Machines

Timers

Understand the Qt Containers

Unicode Character Database (UCD)

Unicode Common Locale Data Repository (CLDR)

XML Japanese Profile

forkfd

http://www.geocities.com/Athens/5180/tsciiset.html

http://www.tamil.net/tscii/

Qt Namespace

application state

widget attributes

window state

window flag

Animation Framework

Event Classes

Input/Output and Networking

JSON Support in Qt

JSON

Overview

The JSON Classes

Plugin Classes

Implicitly Shared Classes

State Machine Classes

Qt Core C++ Classes