doc: Updated the descriptions of the connection types.

Replaced the ambiguous "delivered" with the explanation that the
blocking queued connection type blocks the emitter's thread until
the slot finishes executing in the receiver's thread.

Task-number:  	 QTBUG-6392

2 files changed, 44 insertions, 31 deletions

diff --git a/src/corelib/global/qnamespace.qdoc b/src/corelib/global/qnamespace.qdoc
index 9ef2101..871dd5c 100644
--- a/src/corelib/global/qnamespace.qdoc
+++ b/src/corelib/global/qnamespace.qdoc
@@ -514,45 +514,58 @@
 /*!
     \enum Qt::ConnectionType
 
-    This enum describes the types of connection that can be used between signals and
-    slots. In particular, it determines whether a particular signal is delivered to a
-    slot immediately or queued for delivery at a later time.
+    This enum describes the types of connection that can be used
+    between signals and slots. In particular, it determines whether a
+    particular signal is delivered to a slot immediately or queued for
+    delivery at a later time.
+
+    \value AutoConnection
+    	   (default) Same as DirectConnection, if the emitter and
+       	   receiver are in the same thread. Same as QueuedConnection,
+       	   if the emitter and receiver are in different threads.
+
+    \value DirectConnection  
+	   The slot is invoked immediately, when the signal is
+       	   emitted.
+
+    \value QueuedConnection  
+    	   The slot is invoked when control returns to the event loop
+       	   of the receiver's thread. The slot is executed in the
+       	   receiver's thread.
 
-    \value DirectConnection  When emitted, the signal is immediately delivered to the slot.
-    \value QueuedConnection  When emitted, the signal is queued until the event loop is
-                             able to deliver it to the slot.
     \value BlockingQueuedConnection
-                             Same as QueuedConnection, except that the current thread blocks
-                             until the slot has been delivered. This connection type should
-                             only be used for receivers in a different thread. Note that misuse
-                             of this type can lead to deadlocks in your application.
-    \value AutoConnection    If the signal is emitted from the thread
-                             in which the receiving object lives, the
-                             slot is invoked directly, as with
-                             Qt::DirectConnection; otherwise the
-                             signal is queued, as with
-                             Qt::QueuedConnection.
-    \value UniqueConnection  Same as AutoConnection, but there will be a check that the signal is
-                             not already connected to the same slot before connecting, otherwise,
-                             the connection will fail.
-                             This value was introduced in Qt 4.6.
+           Same as QueuedConnection, except the current thread blocks
+           until the slot returns. This connection type should only be
+           used where the emitter and receiver are in different
+           threads.  \note Violating this rule can cause your
+           application to deadlock.
+
+    \value UniqueConnection
+           Same as AutoConnection, but the connection is made only if
+    	   it does not duplicate an existing connection. i.e., if the
+    	   same signal is already connected to the same slot for the
+    	   same pair of objects, then the connection will fail. This
+    	   connection type was introduced in Qt 4.6.
+
     \value AutoCompatConnection
-           The default connection type for signals and slots when Qt 3 support
-           is enabled. Equivalent to AutoConnection for connections but will cause warnings
-           to be output under certain circumstances. See
-           \l{Porting to Qt 4#Compatibility Signals and Slots}{Compatibility Signals and Slots}
-           for further information.
+    	   The default type when Qt 3 support is enabled. Same as
+	   AutoConnection but will also cause warnings to be output in
+	   certain situations. See \l{Porting to Qt 4#Compatibility
+	   Signals and Slots}{Compatibility Signals and Slots} for
+	   further information.
 
-    With queued connections, the parameters must be of types that are known to
-    Qt's meta-object system, because Qt needs to copy the arguments to store them
-    in an event behind the scenes. If you try to use a queued connection and
-    get the error message
+    With queued connections, the parameters must be of types that are
+    known to Qt's meta-object system, because Qt needs to copy the
+    arguments to store them in an event behind the scenes. If you try
+    to use a queued connection and get the error message:
 
     \snippet doc/src/snippets/code/doc_src_qnamespace.qdoc 0
 
-    call qRegisterMetaType() to register the data type before you
+    Call qRegisterMetaType() to register the data type before you
     establish the connection.
 
+    When using signals and slots with multiple threads, see \l{Signals and Slots Across Threads}.
+
     \sa {Thread Support in Qt}, QObject::connect(), qRegisterMetaType()
 */
 
diff --git a/src/corelib/kernel/qobject.cpp b/src/corelib/kernel/qobject.cpp
index 3564a35..8346fe4 100644
--- a/src/corelib/kernel/qobject.cpp
+++ b/src/corelib/kernel/qobject.cpp
@@ -2456,7 +2456,7 @@ int QObject::receivers(const char *signal) const
     If you pass the Qt::UniqueConnection \a type, the connection will only
     be made if it is not a duplicate. If there is already a duplicate
     (exact same signal to the exact same slot on the same objects),
-    the connection will fail and connect will return false
+    the connection will fail and connect will return false.
 
     The optional \a type parameter describes the type of connection
     to establish. In particular, it determines whether a particular