Provides core non-GUI functionality. More...
These are links to the API reference materials.
|
Contains miscellaneous identifiers used throughout the Qt library |
This page lists classes belonging to Qt Core‘s animation framework.
|
The base of all animations |
|
|
Abstract base class for groups of animations |
|
|
Easing curves for controlling animation |
|
|
Parallel group of animations |
|
|
Pause for QSequentialAnimationGroup |
|
|
Animates Qt properties |
|
|
Sequential group of animations |
|
|
Timeline for controlling animations |
|
|
Abstract base class for animations |
These Qt Core classes provide threading support to applications. The Thread Support in Qt page covers how to use these classes.
|
Platform-independent atomic operations on integers |
|
|
Template class that provides platform-independent atomic operations on pointers |
|
|
Represents the result of an asynchronous computation |
|
|
Convenience class that simplifies QFuture synchronization |
|
|
Allows monitoring a QFuture using signals and slots |
|
|
Access serialization between threads |
|
|
Convenience class that simplifies locking and unlocking mutexes |
|
|
Convenience class that simplifies locking and unlocking read-write locks for read access |
|
|
Read-write locking |
|
|
The base class for all runnable objects |
|
|
General counting semaphore |
|
|
Platform-independent way to manage threads |
|
|
Manages a collection of QThreads |
|
|
Per-thread data storage |
|
|
Condition variable for synchronizing threads |
|
|
Convenience class that simplifies locking and unlocking read-write locks for write access |
|
|
High-level APIs that make it possible to write multi-threaded programs without using low-level threading primitives |
Qt provides the following sequential containers: QList, QLinkedList, QVector, QStack, and QQueue. For most applications, QList is the best type to use. Although it is implemented as an array-list, it provides very fast prepends and appends. If you really need a linked-list, use QLinkedList; if you want your items to occupy consecutive memory locations, use QVector. QStack and QQueue are convenience classes that provide LIFO and FIFO semantics.
Qt also provides these associative containers: QMap, QMultiMap, QHash, QMultiHash, and QSet. The "Multi" containers conveniently support multiple values associated with a single key. The "Hash" containers provide faster lookup by using a hash function instead of a binary search on a sorted set.
As special cases, the QCache and QContiguousCache classes provide efficient hash-lookup of objects in a limited cache storage.
| Class | Summary |
|---|---|
| QList<T> | This is by far the most commonly used container class. It stores a list of values of a given type (T) that can be accessed by index. Internally, the QList is implemented using an array, ensuring that index-based access is very fast.
Items can be added at either end of the list using QList::append() and QList::prepend(), or they can be inserted in the middle using QList::insert(). More than any other container class, QList is highly optimized to expand to as little code as possible in the executable. QStringList inherits from QList<QString>. |
| QLinkedList<T> | This is similar to QList, except that it uses iterators rather than integer indexes to access items. It also provides better performance than QList when inserting in the middle of a huge list, and it has nicer iterator semantics. (Iterators pointing to an item in a QLinkedList remain valid as long as the item exists, whereas iterators to a QList can become invalid after any insertion or removal.) |
| QVector<T> | This stores an array of values of a given type at adjacent positions in memory. Inserting at the front or in the middle of a vector can be quite slow, because it can lead to large numbers of items having to be moved by one position in memory. |
| QStack<T> | This is a convenience subclass of QVector that provides "last in, first out" (LIFO) semantics. It adds the following functions to those already present in QVector: push(), pop(), and top(). |
| QQueue<T> | This is a convenience subclass of QList that provides "first in, first out" (FIFO) semantics. It adds the following functions to those already present in QList: enqueue(), dequeue(), and head(). |
| QSet<T> | This provides a single-valued mathematical set with fast lookups. |
| QMap<Key, T> | This provides a dictionary (associative array) that maps keys of type Key to values of type T. Normally each key is associated with a single value. QMap stores its data in Key order; if order doesn‘t matter QHash is a faster alternative. |
| QMultiMap<Key, T> | This is a convenience subclass of QMap that provides a nice interface for multi-valued maps, i.e. maps where one key can be associated with multiple values. |
| QHash<Key, T> | This has almost the same API as QMap, but provides significantly faster lookups. QHash stores its data in an arbitrary order. |
| QMultiHash<Key, T> | This is a convenience subclass of QHash that provides a nice interface for multi-valued hashes. |
These Qt Core classes deal with shared libraries, (for example, .so and DLL files), and with Qt plugins.
See the How to Create Qt Plugins page for more information.
|
The <QtPlugin> header file defines macros for defining plugins. |
|
|
Abstract base class for plugins provinding accessibility information for user interface elements |
|
|
Abstract base class for plugins |
|
|
Creates plugin drivers |
|
|
Abstract base for custom QIconEngine plugins |
|
|
Defines an interface for writing an image format plugin |
|
|
Loads shared libraries at runtime |
|
|
Loads a plugin at run-time |
|
|
Abstract base for custom QML extension plugins |
|
|
Abstract base for custom QScript extension plugins |
|
|
Abstract base for custom QSqlDriver plugins |
|
|
Abstract base for custom QStyle plugins |
Warning: Be careful with copying an implicitly shared container (QMap, QVector, etc.) while you use STL-style iterator. See Implicit sharing iterator problem.
|
Array of bits |
|
|
Monochrome (1-bit depth) pixmaps |
|
|
Defines the fill pattern of shapes drawn by QPainter |
|
|
Array of bytes |
|
|
List of byte arrays |
|
|
Template class that provides a cache |
|
|
Compares strings according to a localized collation algorithm |
|
|
Can be used to speed up string collation |
|
|
Defines a possible command-line option |
|
|
Template class that provides a contiguous cache |
|
|
Mouse cursor with an arbitrary shape |
|
|
Refers to one pending asynchronous call |
|
|
Holds one Unix file descriptor |
|
|
Date and time functions |
|
|
Output stream for debugging information |
|
|
Access to directory structures and their contents |
|
|
Stores information about a domain name record |
|
|
Stores information about a host address record |
|
|
Stores information about a DNS MX record |
|
|
Stores information about a DNS SRV record |
|
|
Stores information about a DNS TXT record |
|
|
System-independent file information |
|
|
Specifies a font used for drawing text |
|
|
General information about fonts |
|
|
Font metrics information |
|
|
Font metrics information |
|
|
Direct access to the internal glyphs in a font |
|
|
Used in combination with QBrush to specify gradient fills |
|
|
Template class that provides a hash-table-based dictionary |
|
|
Holds a body part to be used inside a HTTP multipart MIME message |
|
|
Scalable icons in different modes and states |
|
|
Hardware-independent image representation that allows direct access to the pixel data, and can be used as a paint device |
|
|
Encapsulates a key sequence as used by shortcuts |
|
|
Template class that provides linked lists |
|
|
Template class that provides lists |
|
|
Converts between numbers and their string representations in various languages |
|
|
Template class that provides a red-black-tree-based dictionary |
|
|
Describes types of file or data, represented by a MIME type string |
|
|
Convenience QHash subclass that provides multi-valued hashes |
|
|
Convenience QMap subclass that provides multi-valued maps |
|
|
Stores one IP address supported by a network interface, along with its associated netmask and broadcast address |
|
|
Cache information |
|
|
Abstraction of one or more access point configurations |
|
|
Holds one network cookie |
|
|
Listing of the host‘s IP addresses and network interfaces |
|
|
Network layer proxy |
|
|
Used to query the proxy settings for a socket |
|
|
Holds a request to be sent with QNetworkAccessManager |
|
|
Wraps an OpenGL debug message |
|
|
Container for painting operations, enabling graphical shapes to be constructed and reused |
|
|
Contains color groups for each widget state |
|
|
Defines how a QPainter should draw lines and outlines of shapes |
|
|
Used to locate data in a data model |
|
|
Paint device that records and replays QPainter commands |
|
|
Off-screen image representation that can be used as a paint device |
|
|
Vector of points using integer precision |
|
|
Vector of points using floating point precision |
|
|
Holds the environment variables that can be passed to a program |
|
|
Generic container that provides a queue |
|
|
Access to a single physical instance of a font |
|
|
Pattern matching using regular expressions |
|
|
Specifies a clip region for a painter |
|
|
Pattern matching using regular expressions |
|
|
The results of a matching a QRegularExpression against a string |
|
|
Iterator on the results of a global match of a QRegularExpression object against a string |
|
|
Template class that provides a hash-table-based set |
|
|
Manipulates the fields in SQL database tables and views |
|
|
Means of executing and manipulating SQL statements |
|
|
Encapsulates a database record |
|
|
Convenient API for an X509 certificate |
|
|
API for accessing the extensions of an X509 certificate |
|
|
Represents an SSL cryptographic cipher |
|
|
Holds the configuration and state of an SSL connection |
|
|
SSL error |
|
|
Interface for private and public keys |
|
|
Template class that provides a stack |
|
|
Enables optimized drawing of text when the text and its layout is updated rarely |
|
|
Provides information about currently mounted storage and drives |
|
|
Unicode character string |
|
|
List of strings |
|
|
Formatting information for blocks of text in a QTextDocument |
|
|
Way of finding Unicode text boundaries in a string |
|
|
Formatting information for characters in a QTextDocument |
|
|
Offers an API to access and modify QTextDocuments |
|
|
Represents a piece of formatted text from a QTextDocument |
|
|
Formatting information for a QTextDocument |
|
|
Formatting information for frames in a QTextDocument |
|
|
Formatting information for images in a QTextDocument |
|
|
Formatting information for lists in a QTextDocument |
|
|
Formatting information for table cells in a QTextDocument |
|
|
Formatting information for tables in a QTextDocument |
|
|
Convenient interface for working with URLs |
|
|
Way to manipulate a key-value pairs in a URL‘s query |
|
|
Acts like a union for the most common Qt data types |
|
|
Template class that provides a dynamic array |
These Qt Core classes are part of the State Machine Framework.
|
The base class of states of a QStateMachine |
|
|
The base class of transitions between QAbstractState objects |
|
|
QObject-specific transition for Qt events |
|
|
Final state |
|
|
Means of returning to a previously active substate |
|
|
Transition for key events |
|
|
Transition for mouse events |
|
|
Transition based on a Qt signal |
|
|
General-purpose state for QStateMachine |
|
|
Hierarchical finite state machine |
|
|
Represents a Qt signal event |
|
|
Inherits QEvent and holds a clone of an event associated with a QObject |
These Qt Core classes are used to handle input and output to and from external devices, processes, files etc. as well as manipulating files and directories.
|
QIODevice interface for a QByteArray |
|
|
Serialization of binary data to a QIODevice |
|
|
Access to directory structures and their contents |
|
|
Interface for reading from and writing to files |
|
|
Interface for reading from and writing to open files |
|
|
System-independent file information |
|
|
Interface for monitoring files and directories for modifications |
|
|
The base interface class of all I/O devices in Qt |
|
|
Format independent interface for reading images from files or other devices |
|
|
Format independent interface for writing images to files or other devices |
|
|
Used to start external programs and to communicate with them |
|
|
Holds the environment variables that can be passed to a program |
|
|
Interface for reading directly from resources |
|
|
Interface for safely writing to files |
|
|
Persistent platform-independent application settings |
|
|
Support for monitoring activity on a file descriptor |
|
|
Provides information about currently mounted storage and drives |
|
|
Creates a unique directory for temporary use |
|
|
I/O device that operates on temporary files |
|
|
Format-independent interface for writing a QTextDocument to files or other devices |
|
|
Convenient interface for reading and writing text |
|
|
Convenient interface for working with URLs |
|
|
Way to manipulate a key-value pairs in a URL‘s query |
These Qt Core classes are used to create and handle events.
For more information see the Event System page.
|
Interface to manage Qt‘s event queue |
|
|
Event that is generated when a QAction is added, removed, or changed |
|
|
Timer events for objects |
|
|
Contains event parameters for child object events |
|
|
Contains parameters that describe a close event |
|
|
Contains parameters that describe a context menu event |
|
|
Event which is sent to a widget when a drag and drop action enters it |
|
|
Event that is sent to a widget when a drag and drop action leaves it |
|
|
Event which is sent while a drag and drop action is in progress |
|
|
Event which is sent when a drag and drop action is completed |
|
|
Contains event parameters for dynamic property change events |
|
|
Contains parameters that describe an enter event |
|
|
The base class of all event classes. Event objects contain event parameters |
|
|
Contains event parameters for expose events |
|
|
Event that will be sent when there is a request to open a file or a URL |
|
|
Contains event parameters for widget focus events |
|
|
The description of triggered gestures |
|
|
Event that is used to request helpful information about a particular point in a widget |
|
|
Event which is sent after a widget is hidden |
|
|
Contains parameters that describe a mouse event |
|
|
Indicates that a main icon drag has begun |
|
|
The base class for events that describe user input |
|
|
Parameters for input method events |
|
|
Describes a key event |
|
|
Contains parameters that describe a mouse event |
|
|
Contains event parameters for move events |
|
|
Contains parameters that describe a gesture event |
|
|
Contains event parameters for paint events |
|
|
Contains event parameters for resize events |
|
|
Sent when scrolling |
|
|
Sent in preparation of scrolling |
|
|
Used to create keyboard shortcuts |
|
|
Event which is generated when the user presses a key combination |
|
|
Event that is sent when a widget is shown |
|
|
Event that is used to show messages in a status bar |
|
|
Contains parameters that describe a Tablet event |
|
|
Repetitive and single-shot timers |
|
|
Contains parameters that describe a timer event |
|
|
Contains parameters that describe a touch event |
|
|
Event that can be used to handle hyperlinks in a "What‘s This?" text |
|
|
Contains parameters that describe a wheel event |
|
|
The window state before a window state change |
原文：http://www.cnblogs.com/hhh5460/p/4268530.html