| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the documentation of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:FDL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Free Documentation License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Free |
| ** Documentation License version 1.3 as published by the Free Software |
| ** Foundation and appearing in the file included in the packaging of |
| ** this file. Please review the following information to ensure |
| ** the GNU Free Documentation License version 1.3 requirements |
| ** will be met: https://www.gnu.org/licenses/fdl-1.3.html. |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| /*! |
| \page topics-core.html |
| \title Core Internals |
| \brief Qt's core topics |
| |
| Qt contains a rich set of fundamental enablers, mainly from the \l{Qt Core} |
| module. Qt uses these enablers to provide higher-level UI and application |
| development components. The following topics explain the most important enablers |
| and show how to use them to implement specialized functionality not already |
| provided by Qt. |
| |
| \section1 Objects, Properties, and Events |
| |
| The QObject class forms the foundation of Qt's object model and is the |
| parent class of many Qt classes. The object model introduces many mechanisms |
| such as a meta-object system which allows run-time introspection, manipulation, |
| and invocation of properties and methods in the object. It also serves as the |
| basis for Qt's event system, which is a low-level way of communicating between |
| QObject-based objects. Another high-level form of communication is provided in |
| Qt's signals and slots mechanism. |
| |
| These features can also be used in combination |
| with the State Machine Framework which provides a formally defined and |
| predictable way of managing the states of your application. |
| An alternative way of implementing state machines is using the |
| \l{Qt SCXML Overview}{Qt SCXML} add-on module to create them from State Chart |
| XML (SCXML) files. |
| |
| In addition, QObject |
| provides a simple timing mechanism with \l QObject::startTimer(). Alternatively, |
| the QTimer class provides a high-level interface for timers. |
| |
| \list |
| \li \l{Object Model} |
| \li \l{The Meta-Object System} |
| \li \l{The Property System} |
| \li \l{The Event System} |
| \li \l{Signals & Slots} |
| \list |
| \li \l{Differences between String-Based and Functor-Based Connections} |
| \endlist |
| \li \l{The State Machine Framework} |
| \li \l{Timers} |
| \endlist |
| |
| \section1 Container Classes |
| |
| A \e container is a data structure whose instances are collections of other |
| objects. Some examples of containers are: dynamic arrays, queues, linked |
| lists, and associative arrays. Qt provides a set of general purpose, |
| template-based container classes for structuring data in memory. |
| |
| See the full list of \l [QtCore]{The Container Classes}{Container Classes} for |
| more details. |
| |
| \section1 Internationalization |
| |
| Qt uses Unicode for the encoding of displayable text strings. Unicode provides |
| support for all commonly used writing systems in the world and is ideal for |
| cross-platform development. Applications can also be written to support any |
| number of different languages with one code base using Qt's powerful |
| internationalization system. |
| |
| \list |
| \li \l{Unicode in Qt} |
| \li \l{Internationalization with Qt} |
| \endlist |
| |
| \section1 Inter-Process Communication |
| |
| Qt provides several classes to support communication between processes. You can |
| also launch and manage external processes using the QProcess class. |
| |
| \list |
| \li \l{Inter-Process Communication in Qt} |
| \endlist |
| |
| \section1 Threading |
| |
| Qt provides functionality to manage threads and parallelized code in a safe and |
| platform-independent way. |
| |
| \list |
| \li \l{Threading Basics} |
| \li \l{Thread Support in Qt} |
| \endlist |
| |
| \section1 Platform Support |
| |
| Qt allows you to write platform-independent code, where the same code base can |
| be compiled for and deployed on different platforms without any changes. In |
| cases where you need to use platform-specific features and integrate with system |
| libraries, Qt also provides solutions for this. |
| |
| Qt integrates with the windowing system on the target platform using Qt |
| Platform Abstraction (QPA). QPA is an abstraction of a windowing system which |
| makes porting Qt to new platforms simple and quick. One such system is the |
| Wayland protocol. Qt can be used together with Wayland as a light-weight |
| windowing system on embedded hardware to support a multi-process graphical user |
| interface. |
| |
| The Qt Platform Abstraction uses Qt's plugin system. This plugin system provides |
| APIs to extend Qt in specific areas (such as adding support for new image |
| formats, database drivers, and so on) and also for writing your own extensible |
| Qt applications which support third-party plugins. |
| |
| \list |
| \li \l{Qt Platform Abstraction} |
| \li \l{Implementing Atomic Operations} - for new architectures |
| \li \l{How to Create Qt Plugins} |
| \li \l{<QtEndian>}{Endian Conversion Functions} - functions for handling |
| endianness from the QtEndian header |
| \endlist |
| */ |