// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only

/*!
    \example threads/queuedcustomtype
    \examplecategory {Data Processing & I/O}
    \title Queued Custom Type
    \ingroup qtconcurrent-mtexamples

    \brief The Queued Custom Type example shows how to send custom types between
    threads with queued signals and slots.

    \image queuedcustomtype-example.png

    \section1 Overview

    In this example, we create a value class, \c Block, and register it with
    the meta-object system to enable us to send instances of it between threads
    using queued signals and slots.

    \section1 The Block Class

    The \c Block class provides the default constructor, copy constructor, and
    a destructor in the public section of the class as required by the
    meta-object system. The class describes a colored rectangle.

    \snippet threads/queuedcustomtype/block.h custom type definition and meta-type declaration

    We will still need to register it with the meta-object system at
    run-time by calling the qRegisterMetaType() template function before
    we make any signal-slot connections that use this type.
    Even though we do not intend to use the type with QVariant in this example,
    it is good practice to also declare the new type with Q_DECLARE_METATYPE().

    The implementation of the \c Block class is trivial, so we avoid quoting
    it here.

    \section1 The Window Class

    We define a simple \c Window class with a public slot that accepts a
    \c Block object. The rest of the class is concerned with managing the
    user interface and handling images.

    \snippet threads/queuedcustomtype/window.h Window class definition

    The \c Window class also contains a worker thread, provided by a
    \c RenderThread object. This will emit signals to send \c Block objects
    to the window's \c addBlock(Block) slot.

    The parts of the \c Window class that are most relevant are the constructor
    and the \c addBlock(Block) slot.

    The constructor creates a thread for rendering images, sets up a user
    interface containing a label and two push buttons that are connected to
    slots in the same class.

    \snippet threads/queuedcustomtype/window.cpp Window constructor start
    \snippet threads/queuedcustomtype/window.cpp set up widgets and connections
    \snippet threads/queuedcustomtype/window.cpp connecting signal with custom type

    In the last of these connections, we connect a signal in the
    \c RenderThread object to the \c addBlock(Block) slot in the window.

    \dots
    \snippet threads/queuedcustomtype/window.cpp Window constructor finish

    The rest of the constructor simply sets up the layout of the window.

    The \c addBlock(Block) slot receives blocks from the rendering thread via
    the signal-slot connection set up in the constructor:

    \snippet threads/queuedcustomtype/window.cpp Adding blocks to the display

    We simply paint these onto the label as they arrive.

    \section1 The RenderThread Class

    The \c RenderThread class processes an image, creating \c Block objects
    and using the \c sendBlock(Block) signal to send them to other components
    in the example.

    \snippet threads/queuedcustomtype/renderthread.h RenderThread class definition

    The constructor and destructor are not quoted here. These take care of
    setting up the thread's internal state and cleaning up when it is destroyed.

    Processing is started with the \c processImage() function, which calls the
    \c RenderThread class's reimplementation of the QThread::run() function:

    \snippet threads/queuedcustomtype/renderthread.cpp processing the image (start)

    Ignoring the details of the way the image is processed, we see that the
    signal containing a block is emitted in the usual way:

    \dots
    \snippet threads/queuedcustomtype/renderthread.cpp processing the image (finish)

    Each signal that is emitted will be queued and delivered later to the
    window's \c addBlock(Block) slot.

    \section1 Registering the Type

    In the example's \c{main()} function, we perform the registration of the
    \c Block class as a custom type with the meta-object system by calling the
    qRegisterMetaType() template function:

    \snippet threads/queuedcustomtype/main.cpp main function

    This call is placed here to ensure that the type is registered before any
    signal-slot connections are made that use it.

    The rest of the \c{main()} function is concerned with setting a seed for
    the pseudo-random number generator, creating and showing the window, and
    setting a default image. See the source code for the implementation of the
    \c createImage() function.

    \section1 Further Reading

    This example showed how a custom type can be registered with the
    meta-object system so that it can be used with signal-slot connections
    between threads.

    In practice, both the Q_DECLARE_METATYPE() macro and the qRegisterMetaType()
    template function can be used to register custom types, but
    qRegisterMetaType() is only required if you need to perform signal-slot
    communication or need to create and destroy objects of the custom type
    at run-time.

    More information on using custom types with Qt can be found in the
    \l{Creating Custom Qt Types} document.
*/
