Merge commit 'qt-mainline/master'

21 files changed, 918 insertions, 16 deletions

diff --git a/doc/src/examples/codeeditor.qdoc b/doc/src/examples/codeeditor.qdoc
index 669ab45..d218d0d 100644
--- a/doc/src/examples/codeeditor.qdoc
+++ b/doc/src/examples/codeeditor.qdoc
@@ -67,7 +67,7 @@
     QTextEdit because it is optimized for handling plain text. See
     the QPlainTextEdit class description for details.
 
-    QPlainTextEdit lets us add selections in addition to the the
+    QPlainTextEdit lets us add selections in addition to the
     selection the user can make with the mouse or keyboard. We use
     this functionality to highlight the current line. More on this
     later.
diff --git a/doc/src/examples/containerextension.qdoc b/doc/src/examples/containerextension.qdoc
index a4fbcea..6d29cf6 100644
--- a/doc/src/examples/containerextension.qdoc
+++ b/doc/src/examples/containerextension.qdoc
@@ -305,7 +305,7 @@
     MultiPageWidget class \l
     {designer/containerextension/multipagewidget.cpp}{implementation}).
     Finally, we implicitly force an update of the page's property
-    sheet by calling the the
+    sheet by calling the
     QDesignerPropertySheetExtension::setChanged() function.
 
     \snippet examples/designer/containerextension/multipagewidgetplugin.cpp 4
diff --git a/doc/src/examples/contiguouscache.qdoc b/doc/src/examples/contiguouscache.qdoc
new file mode 100644
index 0000000..fbfde3f
--- /dev/null
+++ b/doc/src/examples/contiguouscache.qdoc
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example tools/contiguouscache
+    \title Contiguous Cache Example
+
+    The Contiguous Cache example shows how to use QContiguousCache to manage memory usage for
+    very large models.  In some environments memory is limited and, even when it
+    isn't, users still dislike an application using excessive memory.
+    Using QContiguousCache to manage a list, rather than loading
+    the entire list into memory, allows the application to limit the amount
+    of memory it uses, regardless of the size of the data set it accesses
+
+    The simplest way to use QContiguousCache is to cache as items are requested. When
+    a view requests an item at row N it is also likely to ask for items at rows near
+    to N.
+
+    \snippet examples/tools/contiguouscache/randomlistmodel.cpp 0
+
+    After getting the row, the class determines if the row is in the bounds
+    of the contiguous cache's current range.  It would have been equally valid to
+    simply have the following code instead.
+
+    \code
+    while (row > m_rows.lastIndex())
+        m_rows.append(fetchWord(m_rows.lastIndex()+1);
+    while (row < m_rows.firstIndex())
+        m_rows.prepend(fetchWord(m_rows.firstIndex()-1);
+    \endcode
+
+    However a list will often jump rows if the scroll bar is used directly, resulting in
+    the code above causing every row between the old and new rows to be fetched.
+
+    Using QContiguousCache::lastIndex() and QContiguousCache::firstIndex() allows
+    the example to determine what part of the list the cache is currently caching.
+    These values don't represent the indexes into the cache's own memory, but rather
+    a virtual infinite array that the cache represents.
+
+    By using QContiguousCache::append() and QContiguousCache::prepend() the code ensures
+    that items that may be still on the screen are not lost when the requested row
+    has not moved far from the current cache range.  QContiguousCache::insert() can
+    potentially remove more than one item from the cache as QContiguousCache does not
+    allow for gaps.  If your cache needs to quickly jump back and forth between
+    rows with significant gaps between them consider using QCache instead.
+
+    And thats it.  A perfectly reasonable cache, using minimal memory for a very large
+    list.  In this case the accessor for getting the words into the cache
+    generates random information rather than fixed information.  This allows you 
+    to see how the cache range is kept for a local number of rows when running the
+    example.
+
+    \snippet examples/tools/contiguouscache/randomlistmodel.cpp 1
+
+    It is also worth considering pre-fetching items into the cache outside of the
+    application's paint routine.  This can be done either with a separate thread
+    or using a QTimer to incrementally expand the range of the cache prior to
+    rows being requested out of the current cache range.
+*/
diff --git a/doc/src/examples/eventtransitions.qdoc b/doc/src/examples/eventtransitions.qdoc
new file mode 100644
index 0000000..3b956bb
--- /dev/null
+++ b/doc/src/examples/eventtransitions.qdoc
@@ -0,0 +1,86 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example statemachine/eventtransitions
+    \title Event Transitions Example
+
+    The Event Transitions example shows how to use event transitions, a
+    feature of \l{The State Machine Framework}.
+
+    \snippet examples/statemachine/eventtransitions/main.cpp 0
+
+    The \c Window class's constructors begins by creating a button.
+
+    \snippet examples/statemachine/eventtransitions/main.cpp 1
+
+    Two states, \c s1 and \c s2, are created; upon entry they will assign
+    "Outside" and "Inside" to the button's text, respectively.
+
+    \snippet examples/statemachine/eventtransitions/main.cpp 2
+
+    When the button receives an event of type QEvent::Enter and the state
+    machine is in state \c s1, the machine will transition to state \c s2.
+
+    \snippet examples/statemachine/eventtransitions/main.cpp 3
+
+    When the button receives an event of type QEvent::Leave and the state
+    machine is in state \c s2, the machine will transition back to state \c
+    s1.
+
+    \snippet examples/statemachine/eventtransitions/main.cpp 4
+
+    Next, the state \c s3 is created. \c s3 will be entered when the button
+    receives an event of type QEvent::MouseButtonPress and the state machine
+    is in state \c s2. When the button receives an event of type
+    QEvent::MouseButtonRelease and the state machine is in state \c s3, the
+    machine will transition back to state \c s2.
+
+    \snippet examples/statemachine/eventtransitions/main.cpp 5
+
+    Finally, the states are added to the machine as top-level states, the
+    initial state is set to be \c s1 ("Outside"), and the machine is started.
+
+    \snippet examples/statemachine/eventtransitions/main.cpp 6
+
+    The main() function constructs a Window object and shows it.
+
+*/
diff --git a/doc/src/examples/factorial.qdoc b/doc/src/examples/factorial.qdoc
new file mode 100644
index 0000000..2a72e0a
--- /dev/null
+++ b/doc/src/examples/factorial.qdoc
@@ -0,0 +1,102 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example statemachine/factorial
+    \title Factorial States Example
+
+    The Factorial States example shows how to use \l{The State Machine
+    Framework} to calculate the factorial of an integer.
+
+    The statechart for calculating the factorial looks as follows:
+
+    \img factorial-example.png
+    \omit
+    \caption This is a caption
+    \endomit
+
+    In other words, the state machine calculates the factorial of 6 and prints
+    the result.
+
+    \snippet examples/statemachine/factorial/main.cpp 0
+
+    The Factorial class is used to hold the data of the computation, \c x and
+    \c fac. It also provides a signal that's emitted whenever the value of \c
+    x changes.
+
+    \snippet examples/statemachine/factorial/main.cpp 1
+
+    The FactorialLoopTransition class implements the guard (\c x > 1) and
+    calculations (\c fac = \c x * \c fac; \c x = \c x - 1) of the factorial
+    loop.
+
+    \snippet examples/statemachine/factorial/main.cpp 2
+
+    The FactorialDoneTransition class implements the guard (\c x <= 1) that
+    terminates the factorial computation. It also prints the final result to
+    standard output.
+
+    \snippet examples/statemachine/factorial/main.cpp 3
+
+    The application's main() function first creates the application object, a
+    Factorial object and a state machine.
+
+    \snippet examples/statemachine/factorial/main.cpp 4
+
+    The \c compute state is created, and the initial values of \c x and \c fac
+    are defined. A FactorialLoopTransition object is created and added to the
+    state.
+
+    \snippet examples/statemachine/factorial/main.cpp 5
+
+    A final state, \c done, is created, and a FactorialDoneTransition object
+    is created with \c done as its target state. The transition is then added
+    to the \c compute state.
+
+    \snippet examples/statemachine/factorial/main.cpp 6
+
+    The machine's initial state is set to be the \c compute state. We connect
+    the QStateMachine::finished() signal to the QCoreApplication::quit() slot,
+    so the application will quit when the state machine's work is
+    done. Finally, the state machine is started, and the application's event
+    loop is entered.
+
+ */
diff --git a/doc/src/examples/fancybrowser.qdoc b/doc/src/examples/fancybrowser.qdoc
index 9001c20..631aff9 100644
--- a/doc/src/examples/fancybrowser.qdoc
+++ b/doc/src/examples/fancybrowser.qdoc
@@ -40,12 +40,109 @@
 ****************************************************************************/
 
 /*!
-    \example webkit/fancybrowser
-    \title Fancy Browser Example
+   \example webkit/fancybrowser
+  \title Fancy Browser Example
 
     The Fancy Browser example shows how to use jQuery with QtWebKit to
-    make a web browser with some special effects and content manipulation.
+    create a web browser with special effects and content
+    manipulation.
 
     \image fancybrowser-example.png
 
+    The application makes use of QWebFrame::evaluateJavaScript to 
+    evaluate the jQuery JavaScript code. A QMainWindow with a QWebView
+    as central widget builds up the browser itself. 
+
+    \section1 MainWindow Class Definition
+
+    The \c MainWindow class inherits QMainWindow. It implements a number of 
+    slots to perform actions on both the application and on the web content. 
+
+    \snippet examples/webkit/fancybrowser/mainwindow.h 1
+
+    We also declare a QString that contains the jQuery, a QWebView
+    that displays the web content, and a QLineEdit that acts as the
+    address bar.
+
+    \section1 MainWindow Class Implementation
+
+    We start by implementing the constructor. 
+
+    \snippet examples/webkit/fancybrowser/mainwindow.cpp 1
+
+    The first part of the constructor sets the value of \c progress to
+    0. This value will be used later in the code to visualize the
+    loading of a webpage.
+
+    Next, the jQuery library is loaded using a QFile and reading the file 
+    content. The jQuery library is a JavaScript library that provides different 
+    functions for manipulating HTML. 
+
+    \snippet examples/webkit/fancybrowser/mainwindow.cpp 2
+
+    The second part of the constructor creates a QWebView and connects
+    slots to the views signals. Furthermore, we create a QLineEdit as
+    the browsers address bar. We then set the horizontal QSizePolicy
+    to fill the available area in the browser at all times. We add the
+    QLineEdit to a QToolbar together with a set of navigation actions
+    from QWebView::pageAction.  
+
+    \snippet examples/webkit/fancybrowser/mainwindow.cpp 3
+
+    The third and last part of the constructor implements two QMenus and assigns
+    a set of actions to them. The last line sets the QWebView as the central 
+    widget in the QMainWindow.
+
+    \snippet examples/webkit/fancybrowser/mainwindow.cpp 4
+
+    When the page is loaded, \c adjustLocation() updates the address
+    bar; \c adjustLocation() is triggered by the \c loadFinished()
+    signal in QWebView. In \c changeLocation() we create a QUrl
+    object, and then use it to load the page into the QWebView. When
+    the new web page has finished loading, \c adjustLocation() will be
+    run once more to update the address bar.
+
+    \snippet examples/webkit/fancybrowser/mainwindow.cpp 5
+
+    \c adjustTitle() sets the window title and displays the loading
+    progress. This slot is triggered by the \c titleChanged() signal
+    in QWebView. 
+
+    \snippet examples/webkit/fancybrowser/mainwindow.cpp 6
+
+    When a web page has loaded, \c finishLoading() is triggered by the 
+    \c loadFinished() signal in QWebView. \c finishLoading() then updates the 
+    progress in the title bar and calls \c evaluateJavaScript() to evaluate the
+    jQuery library. This evaluates the JavaScript against the current web page. 
+    What that means is that the JavaScript can be viewed as part of the content 
+    loaded into the QWebView, and therefore needs to be loaded every time a new 
+    page is loaded. Once the jQuery library is loaded, we can start executing 
+    the different jQuery functions in the browser.
+
+    \snippet examples/webkit/fancybrowser/mainwindow.cpp 7
+
+    The first jQuery-based function, \c highlightAllLinks(), is designed to  
+    highlight all links in the current webpage. The JavaScript code looks 
+    for web elements named \e {a}, which is the tag for a hyperlink. 
+    For each such element, the background color is set to be yellow by
+    using CSS. 
+
+    \snippet examples/webkit/fancybrowser/mainwindow.cpp 8
+    
+    The \c rotateImages() function rotates the images on the current
+    web page. Webkit supports CSS transforms and this JavaScript code 
+    looks up all \e {img} elements and rotates the images 180 degrees
+    and then back again. 
+
+    \snippet examples/webkit/fancybrowser/mainwindow.cpp 9
+
+    The remaining four methods remove different elements from the current web 
+    page. \c removeGifImages() removes all Gif images on the page by looking up 
+    the \e {src} attribute of all the elements on the web page. Any element with 
+    a \e {gif} file as its source is removed. \c removeInlineFrames() removes all 
+    \e {iframe} or inline elements. \c removeObjectElements() removes all 
+    \e {object} elements, and \c removeEmbeddedElements() removes any elements 
+    such as plugins embedded on the page using the \e {embed} tag.
+
 */
+
diff --git a/doc/src/examples/fortuneserver.qdoc b/doc/src/examples/fortuneserver.qdoc
index e6a7f85..848a3a3 100644
--- a/doc/src/examples/fortuneserver.qdoc
+++ b/doc/src/examples/fortuneserver.qdoc
@@ -45,7 +45,7 @@
 
     The Fortune Server example shows how to create a server for a simple
     network service. It is intended to be run alongside the
-    \l{network/fortuneclient}{Fortune Client} example or the the
+    \l{network/fortuneclient}{Fortune Client} example or the
     \l{network/blockingfortuneclient}{Blocking Fortune Client} example.
 
     \image fortuneserver-example.png Screenshot of the Fortune Server example
diff --git a/doc/src/examples/ftp.qdoc b/doc/src/examples/ftp.qdoc
index 9cc9cd1..7a74a37 100644
--- a/doc/src/examples/ftp.qdoc
+++ b/doc/src/examples/ftp.qdoc
@@ -172,7 +172,7 @@
     no entries were found (in which case our \c addToList() function
     would not have been called). 
 
-    Let's continue with the the \c addToList() slot:
+    Let's continue with the \c addToList() slot:
 
     \snippet examples/network/ftp/ftpwindow.cpp 10
 
@@ -190,7 +190,7 @@
 
     \snippet examples/network/ftp/ftpwindow.cpp 12
 
-    \c cdToParent() is invoked when the the user requests to go to the
+    \c cdToParent() is invoked when the user requests to go to the
     parent directory of the one displayed in the file list. After
     changing the directory, we QFtp::List its contents.
 
diff --git a/doc/src/examples/icons.qdoc b/doc/src/examples/icons.qdoc
index 750ef2e..a81ddb9 100644
--- a/doc/src/examples/icons.qdoc
+++ b/doc/src/examples/icons.qdoc
@@ -479,7 +479,7 @@
     QTableWidget::openPersistentEditor() function to create
     comboboxes for the mode and state columns of the items.
 
-    Due to the the connection between the table widget's \l
+    Due to the connection between the table widget's \l
     {QTableWidget::itemChanged()}{itemChanged()} signal and the \c
     changeIcon() slot, the new image is automatically converted into a
     pixmap and made part of the set of pixmaps available to the icon
diff --git a/doc/src/examples/musicplayerexample.qdoc b/doc/src/examples/musicplayerexample.qdoc
index d23c1f1..9f04bf6 100644
--- a/doc/src/examples/musicplayerexample.qdoc
+++ b/doc/src/examples/musicplayerexample.qdoc
@@ -154,7 +154,7 @@
 
     \snippet examples/phonon/musicplayer/mainwindow.cpp 5
 
-    We move on to the the slots of \c MainWindow, starting with \c
+    We move on to the slots of \c MainWindow, starting with \c
     addFiles(): 
 
     \snippet examples/phonon/musicplayer/mainwindow.cpp 6
diff --git a/doc/src/examples/pingpong.qdoc b/doc/src/examples/pingpong.qdoc
new file mode 100644
index 0000000..040e429
--- /dev/null
+++ b/doc/src/examples/pingpong.qdoc
@@ -0,0 +1,107 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example statemachine/pingpong
+    \title Ping Pong States Example
+
+    The Ping Pong States example shows how to use parallel states together
+    with custom events and transitions in \l{The State Machine Framework}.
+
+    This example implements a statechart where two states communicate by
+    posting events to the state machine. The state chart looks as follows:
+
+    \img pingpong-example.png
+    \omit
+    \caption This is a caption
+    \endomit
+
+    The \c pinger and \c ponger states are parallel states, i.e. they are
+    entered simultaneously and will take transitions independently of
+    eachother.
+
+    The \c pinger state will post the first \c ping event upon entry; the \c
+    ponger state will respond by posting a \c pong event; this will cause the
+    \c pinger state to post a new \c ping event; and so on.
+
+    \snippet examples/statemachine/pingpong/main.cpp 0
+
+    Two custom events are defined, \c PingEvent and \c PongEvent.
+
+    \snippet examples/statemachine/pingpong/main.cpp 1
+
+    The \c Pinger class defines a state that posts a \c PingEvent to the state
+    machine when the state is entered.
+
+    \snippet examples/statemachine/pingpong/main.cpp 2
+
+    The \c PingTransition class defines a transition that is triggered by
+    events of type \c PingEvent, and that posts a \c PongEvent (with a delay
+    of 500 milliseconds) to the state machine when the transition is
+    triggered.
+
+    \snippet examples/statemachine/pingpong/main.cpp 3
+
+    The \c PongTransition class defines a transition that is triggered by
+    events of type \c PongEvent, and that posts a \c PingEvent (with a delay
+    of 500 milliseconds) to the state machine when the transition is
+    triggered.
+
+    \snippet examples/statemachine/pingpong/main.cpp 4
+
+    The main() function begins by creating a state machine and a parallel
+    state group.
+
+    \snippet examples/statemachine/pingpong/main.cpp 5
+
+    Next, the \c pinger and \c ponger states are created, with the parallel
+    state group as their parent state. Note that the transitions are \e
+    targetless. When such a transition is triggered, the source state won't be
+    exited and re-entered; only the transition's onTransition() function will
+    be called, and the state machine's configuration will remain the same,
+    which is precisely what we want in this case.
+
+    \snippet examples/statemachine/pingpong/main.cpp 6
+
+    Finally, the group is added to the state machine, the machine is started,
+    and the application event loop is entered.
+
+  */
diff --git a/doc/src/examples/qobjectxmlmodel.qdoc b/doc/src/examples/qobjectxmlmodel.qdoc
index ce1dab6..37c66bc 100644
--- a/doc/src/examples/qobjectxmlmodel.qdoc
+++ b/doc/src/examples/qobjectxmlmodel.qdoc
@@ -71,7 +71,7 @@
   The query engine can only traverse two dimensional trees, because an
   XML document is always a two dimensional tree. If we want to add the
   QMetaObject tree to the node model, we have to somehow flatten it
-  into the the same plane as the QObject tree. This requires that the
+  into the same plane as the QObject tree. This requires that the
   node model class must build an auxiliary data structure and make it
   part of the two dimensional QObject node model. How to do this is
   explained in \l{Including The QMetaObject Tree}.
diff --git a/doc/src/examples/stickman.qdoc b/doc/src/examples/stickman.qdoc
new file mode 100644
index 0000000..49f4953
--- /dev/null
+++ b/doc/src/examples/stickman.qdoc
@@ -0,0 +1,115 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example animation/stickman
+    \title Stickman Example
+
+    The Stickman example shows how to animate transitions in a state machine to implement key frame 
+    animations.
+
+    \image stickman-example.png
+    
+    In this example, we will write a small application which animates the joints in a skeleton and
+    projects a stickman figure on top. The stickman can be either "alive" or "dead", and when in the
+    "alive" state, he can be performing different actions defined by key frame animations. 
+    
+    Animations are implemented as composite states. Each child state of the animation state 
+    represents a frame in the animation by setting the position of each joint in the stickman's 
+    skeleton to the positions defined for the particular frame. The frames are then bound together 
+    with animated transitions that trigger on the source state's polished() signal. Thus, the 
+    machine will enter the state representing the next frame in the animation immediately after it
+    has finished animating into the previous frame.
+    
+    \image stickman-example1.png
+        
+    The states for an animation is constructed by reading a custom animation file format and 
+    creating states that assign values to the the "position" properties of each of the nodes in the 
+    skeleton graph. 
+    
+    \snippet examples/animation/stickman/lifecycle.cpp 1
+    
+    The states are then bound together with signal transitions that listen to the polished() signal.
+    
+    \snippet examples/animation/stickman/lifecycle.cpp 2
+    
+    The last frame state is given a transition to the first one, so that the animation will loop
+    until it is interrupted when a transition out from the animation state is taken. To get smooth 
+    animations between the different key frames, we set a default animation on the state machine. 
+    This is a parallel animation group which contains animations for all the "position" properties 
+    and will be selected by default when taking any transition that leads into a state that assigns 
+    values to these properties.
+    
+    \snippet examples/animation/stickman/lifecycle.cpp 3
+    
+    Several such animation states are constructed, and are placed together as children of a top 
+    level "alive" state which represents the stickman life cycle. Transitions go from the parent
+    state to the child state to ensure that each of the child states inherit them. 
+    
+    \image stickman-example2.png
+    
+    This saves us the effort of connect every state to every state with identical transitions. The 
+    state machine  makes sure that transitions between the key frame animations are also smooth by 
+    applying the default animation when interrupting one and starting another.
+        
+    Finally, there is a transition out from the "alive" state and into the "dead" state. This is 
+    a custom transition type called LightningSrikesTransition which samples every second and 
+    triggers at random (one out of fifty times on average.) 
+    
+    \snippet examples/animation/stickman/lifecycle.cpp 4
+    
+    When it triggers, the machine will first enter a "lightningBlink" state which uses a timer to 
+    pause for a brief period of time while the background color of the scene is white. This gives us 
+    a flash effect when the lightning strikes.
+    
+    \snippet examples/animation/stickman/lifecycle.cpp 5
+    
+    We start and stop a QTimer object when entering and exiting the state. Then we transition into
+    the "dead" state when the timer times out.
+    
+    \snippet examples/animation/stickman/lifecycle.cpp 0
+    
+    When the machine is in the "dead" state, it will be unresponsive. This is because the "dead" 
+    state has no transitions leading out.
+    
+    \image stickman-example3.png
+    
+*/
diff --git a/doc/src/examples/tabdialog.qdoc b/doc/src/examples/tabdialog.qdoc
index c9500af..5394b82 100644
--- a/doc/src/examples/tabdialog.qdoc
+++ b/doc/src/examples/tabdialog.qdoc
@@ -91,7 +91,7 @@
     \snippet examples/dialogs/tabdialog/tabdialog.cpp 1
     \snippet examples/dialogs/tabdialog/tabdialog.cpp 3
 
-    We arrange the the tab widget above the buttons in the dialog:
+    We arrange the tab widget above the buttons in the dialog:
 
     \snippet examples/dialogs/tabdialog/tabdialog.cpp 4
 
diff --git a/doc/src/examples/tankgame.qdoc b/doc/src/examples/tankgame.qdoc
new file mode 100644
index 0000000..ab3e0f4
--- /dev/null
+++ b/doc/src/examples/tankgame.qdoc
@@ -0,0 +1,117 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example statemachine/tankgame
+    \title Tank Game Example
+
+    The Tank Game example is part of the in \l{The State Machine Framework}. It shows how to use 
+    parallel states to implement artificial intelligence controllers that run in parallel, and error 
+    states to handle run-time errors in parts of the state graph created by external plugins.
+
+    \image tankgame-example.png
+
+    In this example we write a simple game. The application runs a state machine with two main 
+    states: A "stopped" state and a "running" state. The user can load plugins from the disk by 
+    selecting the "Add tank" menu item. 
+    
+    When the "Add tank" menu item is selected, the "plugins" subdirectory in the example's 
+    directory is searched for compatible plugins. If any are found, they will be listed in a 
+    dialog box created using QInputDialog::getItem().
+    
+    \snippet examples/statemachine/tankgame/mainwindow.cpp 1
+    
+    If the user selects a plugin, the application will construct a TankItem object, which inherits
+    from QGraphicsItem and QObject, and which implements an agreed-upon interface using the 
+    meta-object mechanism.
+    
+    \snippet examples/statemachine/tankgame/tankitem.h 0
+    
+    The tank item will be passed to the plugin's create() function. This will in turn return a 
+    QState object which is expected to implement an artificial intelligence which controls the 
+    tank and attempts to destroy other tanks it detects.
+    
+    \snippet examples/statemachine/tankgame/mainwindow.cpp 2
+    
+    Each returned QState object becomes a descendant of a \c region in the "running" state, which is 
+    defined as a parallel state. This means that entering the "running" state will cause each of the 
+    plugged-in QState objects to be entered simultaneously, allowing the tanks to run independently
+    of each other.
+    
+    \snippet examples/statemachine/tankgame/mainwindow.cpp 0
+    
+    The maximum number of tanks on the map is four, and when this number is reached, the 
+    "Add tank" menu item should be disabled. This is implemented by giving the "stopped" state two
+    children which define whether the map is full or not. 
+    
+    \snippet examples/statemachine/tankgame/mainwindow.cpp 5
+    
+    To make sure that we go into the correct child state when returning from the "running" state 
+    (if the "Stop game" menu item is selected while the game is running) we also give the "stopped" 
+    state a history state which we make the initial state of "stopped" state.
+    
+    \snippet examples/statemachine/tankgame/mainwindow.cpp 3
+    
+    Since part of the state graph is defined by external plugins, we have no way of controlling
+    whether they contain errors. By default, run-time errors are handled in the state machine by
+    entering a top level state which prints out an error message and never exits. If we were to 
+    use this default behavior, a run-time error in any of the plugins would cause the "running"
+    state to exit, and thus all the other tanks to stop running as well. A better solution would
+    be if the broken plugin was disabled and the rest of the tanks allowed to continue as before.
+    
+    This is done by setting the error state of the plugin's top-most state to a special error state
+    defined specifically for the plugin in question.
+    
+    \snippet examples/statemachine/tankgame/mainwindow.cpp 4
+    
+    If a run-time error occurs in \c pluginState or any of its descendants, the state machine will
+    search the hierarchy of ancestors until it finds a state whose error state is different from
+    \c null. (Note that if we are worried that a plugin could inadvertedly be overriding our 
+    error state, we could search the descendants of \c pluginState and verify that their error 
+    states are set to \c null before accepting the plugin.)
+    
+    The specialized \c errorState sets the "enabled" property of the tank item in question to false, 
+    causing it to be painted with a red cross over it to indicate that it is no longer running. 
+    Since the error state is a child of the same region in the parallel "running" state as 
+    \c pluginState, it will not exit the "running" state, and the other tanks will continue running
+    without disruption.
+
+*/
diff --git a/doc/src/examples/tooltips.qdoc b/doc/src/examples/tooltips.qdoc
index 5daa2b2..78b350b 100644
--- a/doc/src/examples/tooltips.qdoc
+++ b/doc/src/examples/tooltips.qdoc
@@ -353,7 +353,7 @@
     Whenever the user creates a new shape item, we want the new item
     to appear at a random position, and we use the \c
     randomItemPosition() function to calculate such a position. We
-    make sure that the item appears within the the visible area of the
+    make sure that the item appears within the visible area of the
     \c SortingBox widget, using the widget's current width and heigth
     when calculating the random coordinates.
 
diff --git a/doc/src/examples/trafficinfo.qdoc b/doc/src/examples/trafficinfo.qdoc
index c9b6890..13181cd 100644
--- a/doc/src/examples/trafficinfo.qdoc
+++ b/doc/src/examples/trafficinfo.qdoc
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 ** Contact: Qt Software Information (qt-info@nokia.com)
 **
 ** This file is part of the documentation of the Qt Toolkit.
diff --git a/doc/src/examples/trafficlight.qdoc b/doc/src/examples/trafficlight.qdoc
new file mode 100644
index 0000000..ae62127
--- /dev/null
+++ b/doc/src/examples/trafficlight.qdoc
@@ -0,0 +1,99 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example statemachine/trafficlight
+    \title Traffic Light Example
+
+    The Traffic Light example shows how to use \l{The State Machine Framework}
+    to implement the control flow of a traffic light.
+
+    \image trafficlight-example.png
+
+    In this example we write a TrafficLightWidget class. The traffic light has
+    three lights: Red, yellow and green. The traffic light transitions from
+    one light to another (red to yellow to green to yellow to red again) at
+    certain intervals.
+
+    \snippet examples/statemachine/trafficlight/main.cpp 0
+
+    The LightWidget class represents a single light of the traffic light. It
+    provides an \c on property and two slots, turnOn() and turnOff(), to turn
+    the light on and off, respectively. The widget paints itself in the color
+    that's passed to the constructor.
+
+    \snippet examples/statemachine/trafficlight/main.cpp 1
+
+    The TrafficLightWidget class represents the visual part of the traffic
+    light; it's a widget that contains three lights arranged vertically, and
+    provides accessor functions for these.
+
+    \snippet examples/statemachine/trafficlight/main.cpp 2
+
+    The createLightState() function creates a state that turns a light on when
+    the state is entered, and off when the state is exited. The state uses a
+    timer, and as we shall see the timeout is used to transition from one
+    LightState to another. Here is the statechart for the light state:
+
+    \img trafficlight-example1.png
+    \omit
+    \caption This is a caption
+    \endomit
+
+    \snippet examples/statemachine/trafficlight/main.cpp 3
+
+    The TrafficLight class combines the TrafficLightWidget with a state
+    machine.  The state graph has four states: red-to-yellow, yellow-to-green,
+    green-to-yellow and yellow-to-red. The initial state is red-to-yellow;
+    when the state's timer times out, the state machine transitions to
+    yellow-to-green. The same process repeats through the other states.
+    This is what the statechart looks like:
+
+    \img trafficlight-example2.png
+    \omit
+    \caption This is a caption
+    \endomit
+
+    \snippet examples/statemachine/trafficlight/main.cpp 4
+
+    The main() function constructs a TrafficLight and shows it.
+
+*/
diff --git a/doc/src/examples/transformations.qdoc b/doc/src/examples/transformations.qdoc
index eabb803..58c8b80 100644
--- a/doc/src/examples/transformations.qdoc
+++ b/doc/src/examples/transformations.qdoc
@@ -208,7 +208,7 @@
 
     After transforming the coordinate system, we draw the \c
     RenderArea's shape, and then we restore the painter state using
-    the the QPainter::restore() function (i.e. popping the saved state off
+    the QPainter::restore() function (i.e. popping the saved state off
     the stack).
 
     \snippet examples/painting/transformations/renderarea.cpp 7
diff --git a/doc/src/examples/trollprint.qdoc b/doc/src/examples/trollprint.qdoc
index 38251ee..489012e 100644
--- a/doc/src/examples/trollprint.qdoc
+++ b/doc/src/examples/trollprint.qdoc
@@ -142,7 +142,7 @@
     We can easily determine which file must be changed because the
     translator's "context" is in fact the class name for the class where
     the texts that must be changed appears. In this case the file is \c
-    printpanel.cpp, where the there are four lines to change. Add the
+    printpanel.cpp, where there are four lines to change. Add the
     second argument "two-sided" in the appropriate \c tr() calls to the
     first pair of radio buttons:
 
diff --git a/doc/src/examples/twowaybutton.qdoc b/doc/src/examples/twowaybutton.qdoc
new file mode 100644
index 0000000..87de2e8
--- /dev/null
+++ b/doc/src/examples/twowaybutton.qdoc
@@ -0,0 +1,82 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \example statemachine/twowaybutton
+    \title Two-way Button Example
+
+    The Two-way button example shows how to use \l{The State Machine
+    Framework} to implement a simple state machine that toggles the current
+    state when a button is clicked.
+
+    \snippet examples/statemachine/twowaybutton/main.cpp 0
+
+    The application's main() function begins by constructing the application
+    object, a button and a state machine.
+
+    \snippet examples/statemachine/twowaybutton/main.cpp 1
+
+    The state machine has two states; \c on and \c off. When either state is
+    entered, the text of the button will be set accordingly.
+
+    \snippet examples/statemachine/twowaybutton/main.cpp 2
+
+    When the state machine is in the \c off state and the button is clicked,
+    it will transition to the \c on state; when the state machine is in the \c
+    on state and the button is clicked, it will transition to the \c off
+    state.
+
+    \snippet examples/statemachine/twowaybutton/main.cpp 3
+
+    The states are added to the state machine; they become top-level (sibling)
+    states.
+
+    \snippet examples/statemachine/twowaybutton/main.cpp 4
+
+    The initial state is \c off; this is the state the state machine will
+    immediately transition to once the state machine is started.
+
+    \snippet examples/statemachine/twowaybutton/main.cpp 5
+
+    Finally, the button is resized and made visible, and the application event
+    loop is entered.
+
+*/