/****************************************************************************
**
** 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$
**
****************************************************************************/

/*!
   \group all-examples
   \title List of Qt Examples
   \brief Alphabetical listing of Qt Examples
*/

/*!
    \page examples-layouts.html
    \ingroup all-examples
    \title Layout Examples
    \brief Using Qt's layout-based approach to widget management.

    \image layout-examples.png

    Qt uses a layout-based approach to widget management. Widgets are arranged
    in the optimal positions in windows based on simple layout rules, leading to
    a consistent look and feel. Custom layouts provide more control over the
    positions and sizes of child widgets.

    These \l{Qt Examples and Tutorials}{Qt Examples} demonstrate various
    ways of setting widgets in layouts.

    \list
    \li \l{Basic Layouts Example}{Basic Layouts}
    \li \l{Border Layout Example}{Border Layout}
    \li \l{Dynamic Layouts Example}{Dynamic Layouts}
    \li \l{Flow Layout Example}{Flow Layout}
    \endlist

    \sa {Layout Management}
*/

/*!
    \page examples-draganddrop.html
    \ingroup all-examples
    \title Drag and Drop Examples
    \brief How to access your platform's native drag and drop functionality.

    \image draganddrop-examples.png

    Qt supports native drag and drop on all platforms via an extensible
    MIME-based system that enables applications to send data to each other in the
    most appropriate formats.

    Drag and drop can also be implemented for internal use by applications.

    \list
    \li \l{draganddrop/draggableicons}{Draggable Icons}
    \li \l{draganddrop/draggabletext}{Draggable Text}
    \li \l{draganddrop/dropsite}{Drop Site}\raisedaster
    \li \l{draganddrop/fridgemagnets}{Fridge Magnets}\raisedaster
    \li \l{draganddrop/puzzle}{Drag and Drop Puzzle}
    \endlist

    Examples marked with an asterisk (*) are fully documented.
*/
// This example seems to have disappeared:
//    \li \l{draganddrop/delayedencoding}{Delayed Encoding}\raisedaster


/*!
    \page examples-threadandconcurrent.html
    \ingroup all-examples
    \title Threading and Concurrent Programming Examples
    \brief Threading and concurrent programming in Qt.

    \image thread-examples.png

    Qt makes it easy to write multithreaded applications. Signals and slots can be used
    to safely communicate between threads in your application.
    \omit
    ###Add this explicit list back if the \annotatedlist fails
    \list
    \li \l{threads/queuedcustomtype}{Queued Custom Type}\raisedaster
    \li \l{threads/mandelbrot}{Mandelbrot}\raisedaster
    \li \l{threads/semaphores}{Semaphores}\raisedaster
    \li \l{threads/waitconditions}{Wait Conditions}\raisedaster
    \endlist
    \endomit

    \annotatedlist qtconcurrent-mtexamples

    The QtConcurrent namespace includes a collection of classes and functions
    for straightforward concurrent programming.

    These examples show how to apply the basic techniques of concurrent
    programming to simple problems.
    \omit
    ###Add this explicit list back if the \annotatedlist fails
    \list
    \li \l{qtconcurrent/imagescaling}{QtConcurrent Asynchronous Image Scaling}
    \li \l{qtconcurrent/map}{QtConcurrent Map}
    \li \l{qtconcurrent/progressdialog}{QtConcurrent Progress Dialog}
    \li \l{qtconcurrent/runfunction}{QtConcurrent Run Function}
    \li \l{qtconcurrent/wordcount}{QtConcurrent Word Count}
    \endlist
    \endomit

    \annotatedlist qtconcurrentexamples

    Examples marked with an asterisk (*) are fully documented.
*/

/*!
    \ingroup all-examples
    \title Tools Examples
    \brief Using Qt's containers, iterators, and other tool classes.
    \group examples-widgets-tools

    \image tool-examples.png

    Qt is equipped with a range of capable tool classes, from containers and
    iterators to classes for string handling and manipulation.

    Other classes provide application infrastructure support, handling plugin
    loading and managing configuration files.

*/

/*!
    \group examples-ipc
    \ingroup all-examples
    \title IPC Examples
    \brief Inter-Process Communication with Qt.
*/

/*!
    \page examples-sql.html
    \ingroup all-examples
    \title SQL Examples
    \brief Accessing your SQL database from Qt.

    \image sql-examples.png

    Qt provides extensive database interoperability, with support for products
    from both open source and proprietary vendors.

    SQL support is integrated with Qt's model/view architecture, making it easier
    to provide GUI integration for your database applications.
    \omit
    ###Add this list back if \annotatedlist fails
    \list
     \li \l {Cached Table Example}{Caches Table}
     \li \l {Drill Down Example}{Drill Down}
     \li \l {Master Detail Example}{Master Detail}
     \li \l {Query Model Example}{Query Model}
     \li \l {Relational Table Model Example}{Relational Table}
     \li \l {SQL Browser}
     \li \l {SQL Widget Mapper Example}{SQL Widget Mapper}
     \li \l {Table Model Example}{Table Model}
    \endlist
    \endomit

    \annotatedlist sql_examples

    Examples marked with an asterisk (*) are fully documented.
*/


/*!
    \page examples-xml.html
    \ingroup all-examples
    \title XML Examples
    \brief Using XML with Qt.

    XML parsing and handling is supported through SAX and DOM compliant APIs as well as streaming classes.

    \annotatedlist xml-examples

    \image xml-examples.png XML

    The XQuery/XPath and XML Schema engines in the \l{Qt XML Patterns} module
    provide classes for querying XML files and custom data models.

    \annotatedlist xmlpattern_examples

    Examples marked with an asterisk (*) are fully documented.
*/
/*
###Add these back in to the section above when the examples have documentation

    XML parsing and handling is supported through SAX and DOM compliant APIs
    as well as streaming classes.

    \list
    \li \l{xml/dombookmarks}{DOM Bookmarks}
    \li \l{xml/saxbookmarks}{SAX Bookmarks}
    \li \l{xml/streambookmarks}{QXmlStream Bookmarks}\raisedaster
    \li \l{xml/rsslisting}{RSS-Listing}
    \li \l{xml/xmlstreamlint}{XML Stream Lint Example}\raisedaster
    \li \l{xml/htmlinfo}{XML HTML Info}
    \endlist

    \list
    \li \l{xmlpatterns/recipes}{Recipes}
    \li \l{xmlpatterns/filetree}{File System Example}
    \li \l{xmlpatterns/qobjectxmlmodel}{QObject XML Model Example}
    \li \l{xmlpatterns/xquery/globalVariables}{C++ Source Code Analyzer Example}
    \li \l{xmlpatterns/schema}{XML Schema Validation}\raisedaster
    \endlist

*/

/*!
    \page examples-statemachine.html
    \ingroup all-examples
    \title State Machine Examples
    \brief Using Qt's finite state machine classes.

    Qt provides a powerful hierarchical finite state machine through the Qt State
    Machine classes.

    These examples demonstrate the fundamental aspects of implementing
    Statecharts with Qt.

    \list
    \li \l{statemachine/eventtransitions}{Event Transitions}\raisedaster
    \li \l{statemachine/factorial}{Factorial States}\raisedaster
    \li \l{statemachine/pingpong}{Ping Pong States}\raisedaster
    \li \l{statemachine/rogue}{Rogue}\raisedaster
    \li \l{statemachine/trafficlight}{Traffic Light}\raisedaster
    \li \l{statemachine/twowaybutton}{Two-way Button}\raisedaster
    \endlist

    For more information about using the Qt SCXML module to to create state
    charts from State Chart XML (SCXML) files, see \l {Qt SCXML Examples}.
*/

/*!
    \page examples-animation.html
    \ingroup all-examples
    \title Animation Framework Examples
    \brief Doing animations with Qt.

    \image animation-examples.png Animation

    \list
    \li \l{animation/animatedtiles}{Animated Tiles}
    \li \l{animation/easing}{Easing Curves}
    \li \l{animation/moveblocks}{Move Blocks}\raisedaster
    \li \l{animation/states}{States}
    \li \l{animation/stickman}{Stick man}\raisedaster
    \li \l{animation/sub-attaq}{Sub-Attaq}
    \endlist

    Examples marked with an asterisk (*) are fully documented.
*/

/*!
    \group touchinputexamples
    \ingroup all-examples
    \title Touch Input Examples
    \brief Using Qt's touch input capability.

    Support for touch input makes it possible for developers to create
    extensible and intuitive user interfaces.
*/

/*!
    \page examples-gestures.html
    \title Gestures Examples
    \brief Gesture programming examples.

    The API of the gesture framework is not yet finalized and
    still subject to change.

    \list
    \li \l{gestures/imagegestures}{Image Gestures}
    \endlist
*/

/*!
    \page examples-activeqt.html
    \title ActiveQt Examples
    \brief Using ActiveX from Qt applications.
    \ingroup all-examples

    \image activeqt-examples.png ActiveQt

    \list
    \li \l{activeqt/comapp}{COM App}\raisedaster
    \li \l{Dot Net Example (ActiveQt)}{Dot Net}\raisedaster
    \li \l{activeqt/hierarchy}{Hierarchy}\raisedaster
    \li \l{activeqt/menus}{Menus}\raisedaster
    \li \l{activeqt/multiple}{Multiple}\raisedaster
    \li \l{activeqt/opengl}{OpenGL}\raisedaster
    \li \l{activeqt/qutlook}{Qutlook}\raisedaster
    \li \l{activeqt/simple}{Simple}\raisedaster
    \li \l{activeqt/wrapper}{Wrapper}\raisedaster
    \endlist
*/