Doc: Updates based on sanity checkv5.1.0-beta1

- Removed redundant qdoc pages on supported
platforms, getting source, and building from source.
- Added a module page to list the C++ classes
- Removed unnecessary \module commands in several pages
- Made a few language edits to class documentation
- Updated the index page with some introductory content
- Fixed broken links to the examples

Change-Id: Ia7bd74b383f344426814db736f7bc4cd77c13992
Reviewed-by: Laszlo Papp <lpapp@kde.org>

11 files changed, 93 insertions, 299 deletions

diff --git a/examples/serialport/doc/blockingmaster.qdoc b/examples/serialport/doc/blockingmaster.qdoc
index 40ac0702..4bf4b864 100644
--- a/examples/serialport/doc/blockingmaster.qdoc
+++ b/examples/serialport/doc/blockingmaster.qdoc
@@ -43,17 +43,17 @@
     and performed when the control returns to Qt's event loop. QSerialPort emits
     a signal when the operation is finished. For example, QSerialPort::write()
     returns immediately. When the data is sent to the serial port, QSerialPort
-    emits \l{QSerialPort::bytesWritten()}{bytesWritten()}.
+    emits \l{QIODevice::bytesWritten()}{bytesWritten()}.
 
     \li \e{The synchronous (blocking) approach.} In non-GUI and multithreaded
     applications, the \c waitFor...() functions can be called (i.e.
-    QSerialPort::waitReadyRead()) to suspend the calling thread until the
+    QSerialPort::waitForReadyRead()) to suspend the calling thread until the
     operation has completed.
 
     \endlist
 
     In this example, the synchronous approach is demonstrated. The
-    \l{terminal}{Simple Terminal} example illustrates the
+    \l{terminal}{Terminal} example illustrates the
     asynchronous approach.
 
     The purpose of this example is to demonstrate a pattern that you can use
@@ -102,7 +102,7 @@
     serial port name, timeout and request data from the member data, and then
     releasing the lock again. The case that we are protecting ourselves against
     is that \c transaction() could be called at the same time as we are fetching
-    this data. QString is \l reentrant but \e not \l{thread-safe}, and we must
+    this data. QString is reentrant but not thread-safe, and we must
     also avoid the unlikely risk of reading the serial port name from one request,
     and timeout or request data of another. And as you might have guessed,
     MasterThread can only handle one request at a time.
@@ -158,5 +158,5 @@
 
     \snippet blockingmaster/masterthread.cpp 13
 
-    \sa {Simple Terminal Example}, {Blocking Slave Example}
+    \sa {Terminal Example}, {Blocking Slave Example}
 */
diff --git a/examples/serialport/doc/blockingslave.qdoc b/examples/serialport/doc/blockingslave.qdoc
index 4b835d98..95690dcd 100644
--- a/examples/serialport/doc/blockingslave.qdoc
+++ b/examples/serialport/doc/blockingslave.qdoc
@@ -43,17 +43,18 @@
     and performed when the control returns to Qt's event loop. QSerialPort emits
     a signal when the operation is finished. For example, QSerialPort::write()
     returns immediately. When the data is sent to the serial port, QSerialPort
-    emits \l{QSerialPort::bytesWritten()}{bytesWritten()}.
+    emits \l{QIODevice::bytesWritten()}{bytesWritten()}.
 
     \li \e{The synchronous (blocking) approach.} In non-GUI and multithreaded
     applications, the \c waitFor...() functions can be called (i.e.
-    QSerialPort::waitReadyRead()) to suspend the calling thread until the
+    QSerialPort::waitForReadyRead()) to suspend the calling thread until the
     operation has completed.
 
     \endlist
 
     In this example, the synchronous approach is demonstrated. The
-    \l{slave}{Slave Example} example illustrates the asynchronous approach.
+    \l{terminal}{Terminal} example illustrates the
+    asynchronous approach.
 
     The purpose of this example is to demonstrate a pattern that you can use
     to simplify your serial programming code, without losing responsiveness
@@ -64,7 +65,7 @@
     necessarily add unmanagable complexity to your application.
 
     This application is a Slave, that demonstrate the work paired with Master
-    application \l{blockingmaster}{Blocking Master Example}.
+    application \l{Blocking Master Example}.
 
     The Slave application is receives the request via serial port from
     the Master application and send a response to it.
@@ -104,7 +105,7 @@
     serial port name, timeout and response data from the member data, and then
     releasing the lock again. The case that we are protecting ourselves against
     is that \c startSlave() could be called at the same time as we are fetching
-    this data. QString is \l reentrant but \e not \l{thread-safe}, and we must
+    this data. QString is reentrant but not thread-safe, and we must
     also avoid the unlikely risk of reading the serial port name from one startup,
     call and timeout or response data of another. And as you might have guessed,
     SlaveThread can only handle one startup at a time.
@@ -160,5 +161,5 @@
 
     \snippet blockingslave/slavethread.cpp 13
 
-    \sa {Simple Terminal Example}, {Blocking Master Example}
+    \sa {Terminal Example}, {Blocking Master Example}
 */
diff --git a/examples/serialport/doc/terminal.qdoc b/examples/serialport/doc/terminal.qdoc
index b432390b..e74e237d 100644
--- a/examples/serialport/doc/terminal.qdoc
+++ b/examples/serialport/doc/terminal.qdoc
@@ -48,16 +48,18 @@
     and performed when the control returns to Qt's event loop. QSerialPort emits
     a signal when the operation is finished. For example, QSerialPort::write()
     returns immediately. When the data is sent to the serial port, QSerialPort
-    emits \l{QSerialPort::bytesWritten()}{bytesWritten()}.
+    emits \l{QIODevice::bytesWritten()}{bytesWritten()}.
 
     \li \e{The synchronous (blocking) approach.} In non-GUI and multithreaded
     applications, the \c waitFor...() functions can be called (i.e.
-    QSerialPort::waitReadyRead()) to suspend the calling thread until the
+    QSerialPort::waitForReadyRead()) to suspend the calling thread until the
     operation has completed.
 
     \endlist
 
-    In this example, the asynchronous approach is demonstrated.
+    In this example, the asynchronous approach is demonstrated. The
+    \l{blockingslave}{Blocking Slave} example illustrates the synchronous
+    approach.
 
     Our example contains some GUI widgets:
 
@@ -72,9 +74,9 @@
     main window, displaying the transmitted or received data. The widget is
     derived from the QPlainTextEdit class.
 
-    \li \l{terminal/settingsdialog.cpp}{SettingsDialog} - is a dialog
-    for configuring the serial port, as well as for displaying the available
-    serial ports and information about them.
+    \li \l{terminal/settingsdialog.cpp}{SettingsDialog} - is a dialog for
+    configuring the serial port, as well as for displaying the available serial
+    ports and information about them.
 
     \endlist
 
@@ -87,8 +89,8 @@
     \snippet terminal/mainwindow.cpp 1
 
     The only QSerialPort signal invoked in this example is
-    QSerialPort::readyRead(), which shows that new data has been received and
-    hence available:
+    \l{QIODevice::readyRead()}{readyRead()}, which shows that new data has been
+    received and hence available:
 
     \dots
     \snippet terminal/mainwindow.cpp 2
@@ -140,5 +142,5 @@
     about the selected port, and set the desired parameters of the given serial
     port.
 
-    \sa {Blocking Simple Terminal Example}
+    \sa {Blocking Slave Example}
 */
diff --git a/examples/serialport/examples.qdoc b/examples/serialport/examples.qdoc
index f7dbbf9c..ac95f5a8 100644
--- a/examples/serialport/examples.qdoc
+++ b/examples/serialport/examples.qdoc
@@ -27,11 +27,12 @@
 ****************************************************************************/
 
 /*!
-    \module QtSerialPort
-    \title Examples
+    \title Qt Serial Port Examples
     \page examples.html
-    \previouspage Building and usage
-    \contentspage {Examples} {Contents}
+    \brief List of serial port examples
+
+    The module provides the following examples for reference to
+    help understand the API usage:
 
     \list
     \li \l blockingmaster
diff --git a/src/serialport/doc/qtserialport.qdocconf b/src/serialport/doc/qtserialport.qdocconf
index cf7c0613..f095c2f1 100644
--- a/src/serialport/doc/qtserialport.qdocconf
+++ b/src/serialport/doc/qtserialport.qdocconf
@@ -17,12 +17,7 @@ qhp.QtSerialPort.filterAttributes    = qtserialport $QT_VERSION qtrefdoc
 qhp.QtSerialPort.customFilters.Qt.name = QtSerialPort $QT_VERSION
 qhp.QtSerialPort.customFilters.Qt.filterAttributes = qtserialport $QT_VERSION
 
-qhp.QtSerialPort.subprojects         = overviews classes examples
-
-qhp.QtSerialPort.subprojects.overviews.title = Overview
-qhp.QtSerialPort.subprojects.overviews.indexTitle = Qt Serial Port
-qhp.QtSerialPort.subprojects.overviews.selectors = fake:page,group,module
-qhp.QtSerialPort.subprojects.overviews.sortPages = true
+qhp.QtSerialPort.subprojects         = classes examples
 
 qhp.QtSerialPort.subprojects.classes.title = C++ Classes
 qhp.QtSerialPort.subprojects.classes.indexTitle = Qt Serial Port C++ Classes
diff --git a/src/serialport/doc/src/getsrc.qdoc b/src/serialport/doc/src/getsrc.qdoc
deleted file mode 100644
index 67d17b60..00000000
--- a/src/serialport/doc/src/getsrc.qdoc
+++ /dev/null
@@ -1,63 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2011 -2012 Denis Shienkov <denis.shienkov@gmail.com>
-** 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$
-**
-****************************************************************************/
-
-/*!
-    \module QtSerialPort
-    \title Get source
-    \page getsrc.html
-    \previouspage Introduction
-    \contentspage {Get source} {Contents}
-    \nextpage Building and usage
-
-    \section1 Users
-
-    \code
-    $ git clone git://gitorious.org/qt/qtserialport.git
-    \endcode
-
-    \section1 Developers
-
-    Getting a Qt developer account is necessary to contribute to the project,
-    so that has to be obtained first. Once, that is done, see the following page
-    for further details about the Git and Gerrit usage:
-
-    \l{http://wiki.qt-project.org/Setting_up_Gerrit}{Setting up Gerrit}
-
-    The following command can be used to clone the project with push access:
-
-    \code
-    $ git clone ssh://<username>@codereview.qt-project.org:29418/qt/qtserialport.git
-    \endcode
-
-    If you are in a corporate environment (e.g. behind a firewall) which only
-    allows Ports 80 (HTTP) and 443 (HTTPS), use the following configuration
-    instead:
-
-    \code
-    $ git clone ssh://<username>@codereview.qt-project.org:443/qt/qtserialport.git
-    \endcode
-*/
diff --git a/src/serialport/doc/src/index.qdoc b/src/serialport/doc/src/index.qdoc
index dab757fa..ae5faebc 100644
--- a/src/serialport/doc/src/index.qdoc
+++ b/src/serialport/doc/src/index.qdoc
@@ -26,14 +26,24 @@
 ****************************************************************************/
 
 /*!
-    \module QtSerialPort
+    \page qtserialport-index.html
     \title Qt Serial Port
-    \page index.html
+    \brief Provides API to make the serial programming simple and portable.
 
-    \brief The Qt Serial Port module provides classes to make the serial
-    programming simple and portable.
+    Qt Serial Port provides the basic functionality, which includes
+    configuring, I/O operations, get and set control signals of the
+    RS-232 pinouts.
 
-    Use this form to include Qt Serial Port headers:
+    The following are not supported by this module:
+    \list
+    \li Terminal features such as echo, control CR/LF, and so on.
+    \li Text mode.
+    \li Configuring timeouts and delays while reading.
+    \li Tracking and notification when the state of RS-232 pinout signals change.
+    \endlist
+
+    To use these classes in your application, use the following include
+    statement:
 
     \code
     #include <QtSerialPort/QtSerialPort>
@@ -46,16 +56,10 @@
     QT += serialport
     \endcode
 
-    Table of contents:
-
+    \section1 Related information
     \list
-    \li \l {Introduction}
-    \li \l {Get source}
-    \li \l {Building and usage}
-    \li \l {Examples}
+    \li \l{Qt Serial Port C++ Classes}{C++ Classes}
+    \li \l{Qt Serial Port Examples}{Examples}
     \endlist
 
-    \section1 C++ Classes
-
-    \generatelist annotatedclasses
 */
diff --git a/src/serialport/doc/src/intro.qdoc b/src/serialport/doc/src/intro.qdoc
deleted file mode 100644
index d89a3ce6..00000000
--- a/src/serialport/doc/src/intro.qdoc
+++ /dev/null
@@ -1,77 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2011 - 2012 Denis Shienkov <denis.shienkov@gmail.com>
-** 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$
-**
-****************************************************************************/
-
-/*!
-    \module QtSerialPort
-    \title Introduction
-    \page intro.html
-    \contentspage {Introduction} {Contents}
-    \nextpage Get source
-
-    \section1 History
-
-    Qt Serial Port originated from the third-party library
-    \l{http://gitorious.org/qserialdevice/qserialdevice/trees/2.0}{QSerialDevice 2.0}.
-
-    \section1 Supported platforms
-
-    The primary goal is to support as many common platforms as possible. Please
-    find the information below about the support state for the various
-    platforms:
-
-    \table
-    \header
-        \li Platform
-        \li Support state
-        \li Notes
-    \row
-        \li Windows x86/x64 NT based (2K, XP, Vista, 7, 8)
-        \li Complete support (Tier 1).
-        \li Support expected for Windows 8, but has not yet been tested.
-    \row
-        \li Windows CE
-        \li Partial support (Not Tier 1).
-        \li Tested only with platforms 5 and 6 by using the emulator.
-    \row
-        \li Symbian
-        \li Partial support, and only for legacy Qt4 (Not Tier 1).
-        \li The implementation is not complete and further support in doubt.
-    \row
-        \li Gnu/Linux
-        \li Complete support (Tier 1).
-        \li
-    \row
-        \li Mac OSX
-        \li Complete support (Tier 1).
-        \li
-    \row
-        \li Other *nix
-        \li Complete support (Tier 1).
-        \li All POSIX-compatible.
-    \endtable
-
-*/
diff --git a/src/serialport/doc/src/build.qdoc b/src/serialport/doc/src/qtserialport-module.qdoc
index 13de5e60..b0fc506e 100644
--- a/src/serialport/doc/src/build.qdoc
+++ b/src/serialport/doc/src/qtserialport-module.qdoc
@@ -27,28 +27,20 @@
 
 /*!
     \module QtSerialPort
-    \title Building and usage
-    \page build.html
-    \previouspage Get source
-    \contentspage {Building and usage} {Contents}
-    \nextpage Examples
+    \title Qt Serial Port C++ Classes
+    \brief List of C++ classes that enable access to a serial port.
 
-    \section1 Building
+    To use these classes in your application, use the following include
+    statement:
 
-    Make sure that when you build Qt, that you use the -developer-build option,
-    and do not do a \c{make install} as root. The same branch can be used for
-    building with Qt4 and Qt5.
+    \code
+    #include <QtSerialPort/QtSerialPort>
+    \endcode
 
-    Instructions for building against Qt4 are fundamentally the same as for
-    Qt5. See the information provided below what needs to be done after getting
-    the source by cloning the repository:
+    To link against the module, add this line to your \l qmake \c
+    .pro file:
 
     \code
-    $ cd qtserialport
-    $ qmake
-    $ make (Unix) or jom/nmake (Windows)
+    QT += serialport
     \endcode
-
-    Once having successfully built, the examples can be run to see the intended
-    functionality provided by the module.
 */
diff --git a/src/serialport/qserialport.cpp b/src/serialport/qserialport.cpp
index 2d0d582e..96f06d4b 100644
--- a/src/serialport/qserialport.cpp
+++ b/src/serialport/qserialport.cpp
@@ -89,104 +89,45 @@ int QSerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 /*!
     \class QSerialPort
 
-    \brief The QSerialPort class provides functions to access
-    serial ports.
+    \brief Provides functions to access serial ports.
 
     \reentrant
     \ingroup serialport-main
     \inmodule QtSerialPort
     \since 5.1
 
-    This class resembles the functionality and behavior of the QAbstractSocket
-    class in many aspects, for instance the I/O operations, the implementation
-    of the wait methods, the internal architecture and so forth. Certain
-    QSerialPort method implementations were taken directly from QAbstractSocket
-    with only minor changes.
-
-    The features of the implementation and the conduct of the class are
-    listed below:
-
-    \list
-    \li Provides only common functionality which includes
-    configuring, I/O data stream, get and set control signals of the
-    RS-232 pinouts.
-    \li Does not support for terminal features as echo, control CR/LF and so
-    forth.
-    \li Always works in binary mode.
-    \li Does not support the native ability for configuring timeouts
-    and delays while reading.
-    \li Does not provide tracking and notification when the state
-    of RS-232 pinout signals is changed.
-    \endlist
-
-    To get started with the QSerialPort class, first create an object of
-    that.
-
-    Then, call the setPort() method in order to assign the object with the name
-    of the desired serial port (which has to be present in the system).
-    The name has to follow a certain format, which is platform dependent.
-
-    The helper class QSerialPortInfo allows the enumeration of all the serial
-    ports in the system. This is useful to obtain the correct serial port name.
-
-    The QSerialPortInfo class can also be used as an input parameter for the
-    setPort() method (to retrieve the currently assigned name, use the
-    portName() method).
-
-    After that, the serial port can be opened in read-only (r/o), write-only
-    (w/o) or read-write (r/w) mode using the open() method.
-
-    Note: The serial port is always opened with exclusive access
-    (i.e. no other process or thread can access an already opened serial port).
-
-    Having successfully opened, the QSerialPort determines its current
-    configuration and initializes itself to that. To access the current
-    configuration use the baudRate(), dataBits(), parity(), stopBits(), and
-    flowControl() methods.
-
-    If these settings are satisfying, the I/O operation can be proceed with.
-    Otherwise the port can be reconfigured to the desired setting using the
-    setBaudRate(), setDataBits(), setParity(), setStopBits(), and setFlowControl()
-    methods.
-
-    Read or write the data by calling read() or write(). Alternatively the
-    readLine() and readAll() convenience methods can also be invoked. The
-    QSerialPort class also inherits the getChar(), putChar(), and ungetChar()
-    methods from the QIODevice class. Those methods work on single bytes. The
-    bytesWritten() signal is emitted when data has been written to the serial
-    port. Note that, Qt does not limit the write buffer size, which can be
-    monitored by listening to this signal.
-
-    The readyRead() signal is emitted every time a new chunk of data
-    has arrived. The bytesAvailable() method then returns the number of bytes
-    that are available for reading. Typically, the readyRead() signal would be
-    connected to a slot and all data available could be read in there.
+    You can get information about the available serial ports using the
+    QSerialPortInfo helper class, which allows an enumeration of all the serial
+    ports in the system. This is useful to obtain the correct name of the
+    serial port you want to use. You can pass an object
+    of the helper class as an argument to the setPort() or setPortName()
+    methods to assign the desired serial device.
 
-    If not all the data is read at once, the remaining data will
-    still be available later. Any new incoming data will be
-    appended to the QSerialPort's internal read buffer. In order to limit the
-    size of the read buffer, call setReadBufferSize().
+    After setting the port, you can open it in read-only (r/o), write-only
+    (w/o), or read-write (r/w) mode using the open() method.
+
+    \note The serial port is always opened with exclusive access
+    (that is, no other process or thread can access an already opened serial port).
+
+    Having successfully opened, QSerialPort tries to determine the current
+    configuration of the port and initializes itself. You can reconfigure the
+    port to the desired setting using the setBaudRate(), setDataBits(),
+    setParity(), setStopBits(), and setFlowControl() methods.
 
     The status of the control pinout signals is determined with the
     isDataTerminalReady(), isRequestToSend, and pinoutSignals() methods. To
     change the control line status, use the setDataTerminalReady(), and
     setRequestToSend() methods.
 
-    To close the serial port, call the close() method. After all the pending data
-    has been written to the serial port, the QSerialPort class actually closes
-    the descriptor.
-
-    QSerialPort provides a set of functions that suspend the calling
-    thread until certain signals are emitted. These functions can be
-    used to implement blocking serial ports:
-
-    \list
-    \li waitForReadyRead() blocks until new data is available for
-    reading.
+    Once you know that the ports are ready to read or write, you can
+    use the read() or write() methods. Alternatively the
+    readLine() and readAll() convenience methods can also be invoked.
+    If not all the data is read at once, the remaining data will
+    be available for later as new incoming data is appended to the
+    QSerialPort's internal read buffer. You can limit the size of the read
+    buffer using setReadBufferSize().
 
-    \li waitForBytesWritten() blocks until one payload of data has been
-    written to the serial port.
-    \endlist
+    Use the close() method to close the port and cancel the I/O operations.
 
     See the following example:
 
@@ -214,16 +155,13 @@ int QSerialPortPrivateData::timeoutValue(int msecs, int elapsed)
     However, in a GUI application, blocking serial port should only be
     used in non-GUI threads, to avoid freezing the user interface.
 
-    See the \l master, \l slave, \l blockingmaster, and \l blockingslave
-    examples for an overview of both approaches.
+    For more details about these approaches, refer to the
+    \l {Examples}{example} applications.
 
-    The use of blocking functions is discouraged together with signals. One of
-    the two possibilities should be used.
-
-    The QSerialPort class can be used with QTextStream and QDataStream's stream
-    operators (operator<<() and operator>>()). There is one issue to be aware
-    of, though: make sure that enough data is available before attempting to
-    read by using the operator>>() overloaded operator.
+    The QSerialPort class can also be used with QTextStream and QDataStream's
+    stream operators (operator<<() and operator>>()). There is one issue to be
+    aware of, though: make sure that enough data is available before attempting
+    to read by using the operator>>() overloaded operator.
 
     \sa QSerialPortInfo
 */
@@ -232,8 +170,10 @@ int QSerialPortPrivateData::timeoutValue(int msecs, int elapsed)
     \enum QSerialPort::Direction
 
     This enum describes the possible directions of the data transmission.
-    Note: This enumeration is used for setting the baud rate of the device
-    separately for each direction in case some operating systems (i.e. POSIX-like).
+
+    \note This enumeration is used for setting the baud rate of the device
+    separately for each direction on some operating systems (for example,
+    POSIX-like).
 
     \value Input            Input direction.
     \value Output           Output direction.
diff --git a/src/serialport/qserialportinfo.cpp b/src/serialport/qserialportinfo.cpp
index b78c9eb1..241d344a 100644
--- a/src/serialport/qserialportinfo.cpp
+++ b/src/serialport/qserialportinfo.cpp
@@ -51,8 +51,7 @@ QT_BEGIN_NAMESPACE
 /*!
     \class QSerialPortInfo
 
-    \brief The QSerialPortInfo class provides information about
-    existing serial ports.
+    \brief Provides information about existing serial ports.
 
     \ingroup serialport-main
     \inmodule QtSerialPort