Qt Core: Adding a landing page and sorted the documentation.

-Added \annotatedlist for the groups
-Sorted and placed the pages on the index page.

Change-Id: Id1a4344c0b39f00036f5ac29b1fcb869d5602d2b
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

src/corelib/codecs/codecs.qdoc

@@ -31,10 +31,10 @@
     \ingroup groups
     \brief Codec support in Qt.
 
-    These codecs provide facilities for conversion between Unicode and
-    specific text encodings.
+    These \l{Qt Core} codecs classes provide facilities for conversion between
+    Unicode and specific text encodings.
 
-    \generatelist{related}
+    \annotatedlist codecs
 */
 
 /*!

src/corelib/doc/src/animation.qdoc

@@ -28,6 +28,11 @@
 /*!
     \group animation
     \title Animation Framework
+
+    This page lists classes belonging to \l{Qt Core}'s
+    \l{The Animation Framework}{animation framework}.
+
+    \annotatedlist animation
 */
 
 /*!
@@ -102,7 +107,7 @@
     the framework, please look up their class descriptions.
 
     \section1 Classes in the Animation Framework
-    
+
     These classes provide a framework for creating both simple and complex
     animations.
 
@@ -361,4 +366,3 @@
     framework for animations, see the states example (it lives in the
     \c{examples/animation/states} directory).
 */
-

src/corelib/doc/src/containers.qdoc

@@ -33,12 +33,13 @@
     \brief Collection classes such as list, queue, stack and string, along
     with other classes that can be used without needing QApplication.
 
-    The non-GUI classes are general-purpose collection and string classes
-    that may be used independently of the GUI classes.
+    These \l{Qt Core} non-GUI classes are general-purpose collection and string
+    classes that may be used independently of the GUI classes.
 
     In particular, these classes do not depend on QApplication at all,
     and so can be used in non-GUI programs.
 
+    \annotatedlist tools
 */
 
 /*!
@@ -394,13 +395,13 @@
     QMapIterator, which is somewhat different because it iterates on
     (key, value) pairs.
 
-    Like QListIterator, QMapIterator provides 
-    \l{QMapIterator::toFront()}{toFront()}, 
-    \l{QMapIterator::toBack()}{toBack()}, 
-    \l{QMapIterator::hasNext()}{hasNext()}, 
-    \l{QMapIterator::next()}{next()}, 
-    \l{QMapIterator::peekNext()}{peekNext()}, 
-    \l{QMapIterator::hasPrevious()}{hasPrevious()}, 
+    Like QListIterator, QMapIterator provides
+    \l{QMapIterator::toFront()}{toFront()},
+    \l{QMapIterator::toBack()}{toBack()},
+    \l{QMapIterator::hasNext()}{hasNext()},
+    \l{QMapIterator::next()}{next()},
+    \l{QMapIterator::peekNext()}{peekNext()},
+    \l{QMapIterator::hasPrevious()}{hasPrevious()},
     \l{QMapIterator::previous()}{previous()}, and
     \l{QMapIterator::peekPrevious()}{peekPrevious()}. The key and
     value components are extracted by calling key() and value() on

src/corelib/doc/src/eventsandfilters.qdoc

@@ -32,10 +32,11 @@
 
     \brief Classes used to create and handle events.
 
-    These classes are used to create and handle events.
+    These \l{Qt Core} classes are used to create and handle events.
 
-    For more information see the \link object.html Object model\endlink
-    and \link signalsandslots.html Signals and Slots\endlink.
+    For more information see the \l{The Event System}{Event System} page.
+
+    \annotatedlist events
 */
 
 /*!

src/corelib/doc/src/implicit-sharing.qdoc

@@ -31,6 +31,12 @@
 /*!
     \group shared
     \title Implicitly Shared Classes
+
+    These \l{Qt Core} classes provides a safe and efficient way of sharing and
+    manipulating data by \l{Implicit Sharing}{implicitly sharing} data.
+
+    \annotatedlist shared
+
 */
 
 /*!

src/corelib/doc/src/io.qdoc

@@ -33,7 +33,9 @@
     \brief Classes providing file input and output along with directory and
     network handling.
 
-    These classes are used to handle input and output to and from external
-    devices, processes, files etc. as well as manipulating files and directories.
-*/
+    These \l{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.
 
+    \annotatedlist io
+*/

src/corelib/doc/src/json.qdoc

@@ -108,5 +108,6 @@
 
     \annotatedlist json
 
-    All JSON classes are value based, implicitly shared classes.
+    All JSON classes are value based,
+    \l{Implicit Sharing}{implicitly shared classes}.
 */

src/corelib/doc/src/plugins-howto.qdoc

@@ -32,12 +32,14 @@
 
     \brief Plugin related classes.
 
-    These classes deal with shared libraries, (e.g. .so and DLL files),
-    and with Qt plugins.
+    These \l{Qt Core} classes deal with shared libraries, (e.g. .so and DLL
+    files), and with Qt plugins.
 
-    See the \link plugins-howto.html plugins documentation\endlink.
+    See the \l{How to Create Qt Plugins} page for more information..
 
     See also the \l{ActiveQt framework} for Windows.
+
+    \annotatedlist plugins
 */
 
 /*!

src/corelib/doc/src/qtcore-index.qdoc

@@ -0,0 +1,121 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** 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 Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/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: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \page qtcore-index.html
+    \title Qt Core
+    \ingroup modules
+
+    \brief The Qt Core module is part of Qt's essential modules.
+
+    \section1 Getting Started
+    All other Qt modules rely on this module. To include the
+    definitions of the module's classes, use the following directive:
+
+    \snippet code/doc_src_qtcore.cpp 0
+
+    \section1 Core Functionalities
+
+    Qt adds these features to C++:
+
+    \list
+    \li a very powerful mechanism for seamless object communication called
+    signals and slots
+    \li queryable and designable object properties
+    \li hierarchical and queryable object trees that organize
+    \li object ownership in a natural way with guarded pointers (QPointer)
+    \li a dynamic cast that works across library boundaries
+    \endlist
+
+    The following pages provide more information about Qt's core features:
+    \list
+    \li \l{The Meta-Object System}
+    \li \l{The Property System}
+    \li \l{Object Model}
+    \li \l{Object Trees & Ownership}
+    \li \l{Signals & Slots}
+    \endlist
+
+    \section1 Threading and Concurrent Programming
+
+    Qt provides thread support in the form of platform-independent \l{Threading
+    Classes}{threading classes}, a thread-safe way of posting events, and
+    signal-slot connections across threads. Multithreaded programming is also a
+    useful paradigm for performing time-consuming operations without freezing
+    the user interface of an application.
+
+    The \l{Thread Support in Qt} page contains information on implementing
+    threads in applications. Additional concurrent classes are provided by the
+    \l{Qt Concurrent} module.
+
+    \section1 Input/Output, Resources, and Containers
+
+    Qt provides a resource system for organizing application files and assets,
+    a set of containers, and classes for receiving input and printing output.
+    \list
+    \li \l{Container Classes}
+    \li \l{Serializing Qt Data Types}
+    \li \l{Implicit Sharing}
+    \endlist
+
+    In addition, Qt Core provides a platform-independent mechanism for storing
+    binary files in the application's executable.
+
+    \list
+    \li \l{The Qt Resource System}
+    \endlist
+
+    \section1 Additional Frameworks
+    Qt Core also provides some of Qt's key frameworks.
+
+    \list
+    \li \l{The Animation Framework}
+    \li \l{JSON Support in Qt}
+    \li \l{The State Machine Framework}
+    \li \l{How to Create Qt Plugins}
+    \li \l{The Event System}
+    \endlist
+
+    \section1 Related Information
+    \section1 Reference
+    These are links to the API reference materials.
+    \list
+    \li \l{Qt Core C++ Classes}{C++ classes}
+        \list
+        \li \l{Animation Framework}{Animation Classes}
+        \li \l{Threading Classes}
+        \li \l{Non-GUI Classes}
+        \li \l{Container Classes}
+        \li \l{Plugin Classes}
+        \li \l{Implicitly Shared Classes}
+        \li \l{State Machine Classes}
+        \li \l{Input/Output and Networking}{Input/Output Classes}
+        \li \l{Event Classes}
+        \endlist
+    \endlist
+
+*/

src/corelib/doc/src/qtcore.qdoc

@@ -27,16 +27,13 @@
 
 /*!
     \module QtCore
-    \title QtCore Module
+    \title Qt Core C++ Classes
     \ingroup modules
 
-    \keyword QtCore
-
-    \brief The QtCore module contains core non-GUI functionality.
+    \brief Provides core non-GUI functionality.
 
     All other Qt modules rely on this module. To include the
     definitions of the module's classes, use the following directive:
 
     \snippet code/doc_src_qtcore.cpp 0
 */
-

src/corelib/doc/src/statemachine.qdoc

@@ -28,6 +28,11 @@
 /*!
     \group statemachine
     \title State Machine Classes
+
+    These \l{Qt Core} classes are part of the \l{The State Machine Framework}{
+    State Machine Framework}.
+
+    \annotatedlist statemachine
 */
 
 /*!
@@ -69,7 +74,7 @@
   \section1 Classes in the State Machine Framework
 
   These classes are provided by qt for creating event-driven state machines.
-  
+
   \annotatedlist statemachine
 
   \section1 A Simple State Machine

src/corelib/doc/src/threads.qdoc

@@ -28,6 +28,10 @@
 /*!
     \group thread
     \title Threading Classes
+
+    These \l{Qt Core} classes provide threading support to applications.
+    The \l{Thread Support in Qt} page covers how to use these classes.
+    \annotatedlist thread
 */
 
 /*!
@@ -111,13 +115,13 @@
 /*!
     \page threads-starting.html
     \title Starting Threads with QThread
-    
+
     \contentspage Thread Support in Qt
     \nextpage Synchronizing Threads
 
     A QThread instance represents a thread and provides the means to
     \l{QThread::start()}{start()} a thread, which will then execute the
-    reimplementation of QThread::run(). The \c run() implementation is for a 
+    reimplementation of QThread::run(). The \c run() implementation is for a
     thread what the \c main() entry point is for the application. All code
     executed in a call stack that starts in the \c run() function is executed
     by the new thread, and the thread finishes when the function returns.
@@ -141,12 +145,12 @@
     Then, create an instance of the thread object and call
     QThread::start(). Note that you must create the QApplication (or
     QCoreApplication) object before you can create a QThread.
-    
-    The function will return immediately and the 
+
+    The function will return immediately and the
     main thread will continue. The code that appears in the
     \l{QThread::run()}{run()} reimplementation will then be executed
     in a separate thread.
-    
+
     Creating threads is explained in more detail in the QThread
     documentation.
 
@@ -160,7 +164,7 @@
 /*!
     \page threads-synchronizing.html
     \title Synchronizing Threads
-    
+
     \previouspage Starting Threads with QThread
     \contentspage Thread Support in Qt
     \nextpage Reentrancy and Thread-Safety
@@ -227,7 +231,7 @@
 
     \list
     \li A \e thread-safe function can be called simultaneously from
-       multiple threads, even when the invocations use shared data, 
+       multiple threads, even when the invocations use shared data,
        because all references to the shared data are serialized.
     \li A \e reentrant function can also be called simultaneously from
        multiple threads, but only if each invocation uses its own data.
@@ -577,8 +581,8 @@
 
     \endlist
 
-    Qt Concurrent supports several STL-compatible container and iterator types, 
-    but works best with Qt containers that have random-access iterators, such as 
+    Qt Concurrent supports several STL-compatible container and iterator types,
+    but works best with Qt containers that have random-access iterators, such as
     QList or QVector. The map and filter functions accept both containers and begin/end iterators.
 
     STL Iterator support overview:
@@ -609,14 +613,14 @@
         \li QList, QVector, std::vector
         \li Supported and Recommended
     \endtable
-    
+
     Random access iterators can be faster in cases where Qt Concurrent is iterating
     over a large number of lightweight items, since they allow skipping to any point
     in the container. In addition, using random access iterators allows Qt Concurrent
     to provide progress information trough QFuture::progressValue() and QFutureWatcher::
     progressValueChanged().
 
-    The non in-place modifying functions such as mapped() and filtered() makes a 
+    The non in-place modifying functions such as mapped() and filtered() makes a
     copy of the container when called. If you are using STL containers this copy operation
     might take some time, in this case we recommend specifying the begin and end iterators
     for the container instead.
@@ -643,7 +647,7 @@
 
     QPainter can be used in a thread to paint onto QImage, QPrinter, and
     QPicture paint devices. Painting onto QPixmaps and QWidgets is \e not
-    supported. On Mac OS X the automatic progress dialog will not be 
+    supported. On Mac OS X the automatic progress dialog will not be
     displayed if you are printing from outside the GUI thread.
 
     Any number of threads can paint at any given time, however only