QtCore Module

High-level APIs that make it possible to write multi-threaded programs without using low-level threading primitives

The base of all animations

Abstraction for accessing the filesystem

Iterator interface for custom file engines

Abstract model that can be subclassed to create one-dimensional list models

Abstract model that can be subclassed to create table models

Abstract base class for groups of animations

Template class that provides platform-independent atomic operations on pointers

Array of bits

Array of bytes

Template class that provides a cache

Contains event parameters for child object events

Template class that provides a contiguous cache

Way to generate cryptographic hashes

Serialization of binary data to a QIODevice

Date and time functions

Access to directory structures and their contents

Contains event parameters for dynamic property change events

Fast way to calculate elapsed times

Means of entering and leaving an event loop

Represents a pointer to an explicitly shared object

Interface for reading from and writing to files

Interface for monitoring files and directories for modifications

Helper data type for QFlags

Represents the result of an asynchronous computation

Convenience class that simplifies QFuture synchronization

Internal helper class for marshalling arguments

Template class that provides a hash-table-based dictionary

Means of returning to a previously active substate

8-bit ASCII/Latin-1 character

Loads shared libraries at runtime

Two-dimensional vector using integer precision

Template class that provides linked lists

Template class that provides lists

Converts between numbers and their string representations in various languages

Java-style const iterator for QMap and QMultiMap

Additional information about a class

Meta-data about a member function

Meta-data about a property

Container for data that records information about its MIME type

Convenience QHash subclass that provides multi-valued hashes

Java-style non-const iterator for QHash and QMultiHash

Java-style non-const iterator for QList and QQueue

Java-style non-const iterator for QSet

Access serialization between threads

The base class of all Qt objects

Template class that stores a pair of items

Pause for QSequentialAnimationGroup

Loads a plugin at run-time

Defines a point in the plane using floating point precision

Used to start external programs and to communicate with them

Animates Qt properties

Convenience class that simplifies locking and unlocking read-write locks for read access

Defines a rectangle in the plane using integer precision

Pattern matching using regular expressions

The base class for all runnable objects

Stores a pointer to a dynamically allocated object, and deletes it upon destruction

Sequential group of animations

Java-style const iterator for QSet

Base class for shared data objects

Access to a shared memory segment

Bundles signals from identifiable senders

Defines the size of a two-dimensional object using integer point precision

Support for monitoring activity on a file descriptor

General-purpose state for QStateMachine

Unicode character string

Holds a sequence of characters that can be quickly matched in a Unicode string

Information about the system

General counting system semaphore

Way of finding Unicode text boundaries in a string

Abstract base for custom QTextCodec plugins

State-based encoder

Convenience class for output streams

Platform-independent threads

Per-thread data storage

Timeline for controlling animations

Contains parameters that describe a timer event

Convenient interface for working with URLs

Low-level variable-length array

Abstract base class for animations

Java-style const iterator for QVector and QStack

Holds a weak reference to a shared pointer

Represents a single XML attribute

Represents a DTD entity declaration

Represents a namespace declaration

Fast parser for reading well-formed XML via a simple streaming API

Represents an unhandled exception in a worker thread