Whitespace cleanup: remove trailing whitespace

Remove all trailing whitespace from the following list of files:
*.cpp *.h *.conf *.qdoc *.pro *.pri *.mm *.rc *.pl *.qps *.xpm *.txt *README
excluding 3rdparty, test-data and auto generated code.

Note A): the only non 3rdparty c++-files that still
have trailing whitespace after this change are:
* src/corelib/codecs/cp949codetbl_p.h
* src/corelib/codecs/qjpunicode.cpp
* src/corelib/codecs/qbig5codec.cpp
* src/corelib/xml/qxmlstream_p.h
* src/tools/qdoc/qmlparser/qqmljsgrammar.cpp
* src/tools/uic/ui4.cpp
* tests/auto/other/qtokenautomaton/tokenizers/*
* tests/benchmarks/corelib/tools/qstring/data.cpp
* util/lexgen/tokenizer.cpp

Note B): in about 30 files some overlapping 'leading tab' and
'TAB character in non-leading whitespace' issues have been fixed
to make the sanity bot happy. Plus some general ws-fixes here
and there as asked for during review.

Change-Id: Ia713113c34d82442d6ce4d93d8b1cf545075d11d
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>

5 files changed, 32 insertions, 32 deletions

diff --git a/src/concurrent/qtconcurrentfilter.cpp b/src/concurrent/qtconcurrentfilter.cpp
index 72362b7d8a..ef0229a695 100644
--- a/src/concurrent/qtconcurrentfilter.cpp
+++ b/src/concurrent/qtconcurrentfilter.cpp
@@ -148,7 +148,7 @@
 
     QtConcurrent::filter(), QtConcurrent::filtered(), and
     QtConcurrent::filteredReduced() accept function objects, which can be used to
-    add state to a function call. The result_type typedef must define the 
+    add state to a function call. The result_type typedef must define the
     result type of the function call operator:
 
     \snippet code/src_concurrent_qtconcurrentfilter.cpp 13
diff --git a/src/concurrent/qtconcurrentmap.cpp b/src/concurrent/qtconcurrentmap.cpp
index 2dba3779ff..9718baf48f 100644
--- a/src/concurrent/qtconcurrentmap.cpp
+++ b/src/concurrent/qtconcurrentmap.cpp
@@ -56,7 +56,7 @@
 
 /*!
     \enum QtConcurrent::ReduceOption
-    This enum specifies the order of which results from the map or filter 
+    This enum specifies the order of which results from the map or filter
     function are passed to the reduce function.
 
     \value UnorderedReduce Reduction is done in an arbitrary order.
@@ -197,7 +197,7 @@
 
     QtConcurrent::map(), QtConcurrent::mapped(), and
     QtConcurrent::mappedReduced() accept function objects, which can be used to
-    add state to a function call. The result_type typedef must define the 
+    add state to a function call. The result_type typedef must define the
     result type of the function call operator:
 
     \snippet code/src_concurrent_qtconcurrentmap.cpp 14
@@ -347,7 +347,7 @@
   Calls \a function once for each item from \a begin to \a end and returns a
   container with the results. Specify the type of container as the a template
   argument, like this:
-  
+
   \code
      QList<int> ints = QtConcurrent::blockingMapped<QList<int> >(beginIterator, endIterator, fn);
   \endcode
diff --git a/src/concurrent/qtconcurrentmapkernel.h b/src/concurrent/qtconcurrentmapkernel.h
index b456c42285..6817cd3e29 100644
--- a/src/concurrent/qtconcurrentmapkernel.h
+++ b/src/concurrent/qtconcurrentmapkernel.h
@@ -80,7 +80,7 @@ public:
             runIteration(it, i, 0);
             advance(it, 1);
         }
-       
+
         return false;
     }
 };
diff --git a/src/concurrent/qtconcurrentreducekernel.h b/src/concurrent/qtconcurrentreducekernel.h
index a4a626d6c9..dcf4b92319 100644
--- a/src/concurrent/qtconcurrentreducekernel.h
+++ b/src/concurrent/qtconcurrentreducekernel.h
@@ -139,7 +139,7 @@ class ReduceKernel
 
 public:
     ReduceKernel(ReduceOptions _reduceOptions)
-        : reduceOptions(_reduceOptions), progress(0), resultsMapSize(0), 
+        : reduceOptions(_reduceOptions), progress(0), resultsMapSize(0),
           threadCount(QThreadPool::globalInstance()->maxThreadCount())
     { }
 
diff --git a/src/concurrent/qtconcurrentrun.cpp b/src/concurrent/qtconcurrentrun.cpp
index 880441cfc3..4ab1399c0c 100644
--- a/src/concurrent/qtconcurrentrun.cpp
+++ b/src/concurrent/qtconcurrentrun.cpp
@@ -47,63 +47,63 @@
     separate thread.
 
     \ingroup thread
-    
+
     This function is a part of the \l {Concurrent Programming}{Qt Concurrent} framework.
 
     The QtConcurrent::run() function runs a function in a separate thread.
     The return value of the function is made available through the QFuture API.
-    
+
     \section1 Running a Function in a Separate Thread
-    
+
     To run a function in another thread, use QtConcurrent::run():
-    
+
     \snippet code/src_concurrent_qtconcurrentrun.cpp 0
-    
+
     This will run \e aFunction in a separate thread obtained from the default
     QThreadPool. You can use the QFuture and QFutureWatcher classes to monitor
     the status of the function.
-    
+
     \section1 Passing Arguments to the Function
 
     Passing arguments to the function is done by adding them to the
     QtConcurrent::run() call immediately after the function name. For example:
-    
+
     \snippet code/src_concurrent_qtconcurrentrun.cpp 1
-    
+
     A copy of each argument is made at the point where QtConcurrent::run() is
     called, and these values are passed to the thread when it begins executing
     the function. Changes made to the arguments after calling
     QtConcurrent::run() are \e not visible to the thread.
-    
+
     \section1 Returning Values from the Function
-    
+
     Any return value from the function is available via QFuture:
-    
+
     \snippet code/src_concurrent_qtconcurrentrun.cpp 2
-    
+
     As documented above, passing arguments is done like this:
-    
+
     \snippet code/src_concurrent_qtconcurrentrun.cpp 3
-    
+
     Note that the QFuture::result() function blocks and waits for the result
     to become available. Use QFutureWatcher to get notification when the
     function has finished execution and the result is available.
-    
+
     \section1 Additional API Features
-    
+
     \section2 Using Member Functions
-    
+
     QtConcurrent::run() also accepts pointers to member functions. The first
     argument must be either a const reference or a pointer to an instance of
     the class. Passing by const reference is useful when calling const member
     functions; passing by pointer is useful for calling non-const member
     functions that modify the instance.
-    
+
     For example, calling QByteArray::split() (a const member function) in a
     separate thread is done like this:
-    
+
     \snippet code/src_concurrent_qtconcurrentrun.cpp 4
-    
+
     Calling a non-const member function is done like this:
 
     \snippet code/src_concurrent_qtconcurrentrun.cpp 5
@@ -115,17 +115,17 @@
     \l{http://www.boost.org/libs/bind/bind.html}{Boost} or
     \l{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf}
     {C++ TR1 Library Extensions}.
-    
+
     You can use boost::bind() or std::tr1::bind() to \e bind a number of
     arguments to a function when called. There are number of reasons for doing
     this:
-    
+
     \list
     \li To call a function that takes more than 5 arguments.
     \li To simplify calling a function with constant arguments.
     \li Changing the order of arguments.
     \endlist
-    
+
     See the documentation for the relevant functions for details on how to use
     the bind API.
 
@@ -137,14 +137,14 @@
 /*!
     \fn QFuture<T> QtConcurrent::run(Function function, ...);
     \relates <QtConcurrentRun>
-    
+
     Runs \a function in a separate thread. The thread is taken from the global
     QThreadPool. Note that the function may not run immediately; the function
     will only be run when a thread is available.
-    
+
     T is the same type as the return value of \a function. Non-void return
     values can be accessed via the QFuture::result() function.
-    
+
     Note that the QFuture returned by QtConcurrent::run() does not support
     canceling, pausing, or progress reporting. The QFuture returned can only
     be used to query for the running/finished status and the return value of