doc fixes

9 files changed, 56 insertions, 56 deletions

diff --git a/doc/src/declarative/anchor-layout.qdoc b/doc/src/declarative/anchor-layout.qdoc
index 6f047a4..60eefe0 100644
--- a/doc/src/declarative/anchor-layout.qdoc
+++ b/doc/src/declarative/anchor-layout.qdoc
@@ -1,13 +1,13 @@
 /*!
 \page anchor-layout.html
 \target anchor-layout
-\title Anchor-based Layout
+\title Anchor-based Layout in QML
 
 In addition to the more traditional \l Grid, \l Row, and \l Column, QML also provides a way to layout items using the concept of anchors. Each item can be thought of as having a set of 6 invisible "anchor lines": \e left, \e horizontalCenter, \e right, \e top, \e verticalCenter, and \e bottom.
 
 \image edges_qml.png
 
-The Fx anchoring system allows you to define relationships between the anchor lines of different items. For example, you can write:
+The QML anchoring system allows you to define relationships between the anchor lines of different items. For example, you can write:
 
 \code
 Rectangle { id: Rect1; ... }
diff --git a/doc/src/declarative/binding.qdoc b/doc/src/declarative/binding.qdoc
index 064f686..dfddf75 100644
--- a/doc/src/declarative/binding.qdoc
+++ b/doc/src/declarative/binding.qdoc
@@ -1,6 +1,6 @@
 /*!
 \page binding.html
-\title Data Binding
+\title Data Binding in QML
 \target binding
 
 Data binding provides a declarative way of specifying the data associated with objects, as well as the relationship between data of different objects. For example, you could bind the text of a label to the value of a slider: as the value of the slider changed, the label would be automatically updated with the new value.
diff --git a/doc/src/declarative/cppitem.qdoc b/doc/src/declarative/cppitem.qdoc
index 794f67a..4543156 100644
--- a/doc/src/declarative/cppitem.qdoc
+++ b/doc/src/declarative/cppitem.qdoc
@@ -1,7 +1,7 @@
-/*! 
+/*!
 \page cppitem.html
 \target cppitem
-\title C++ Components
+\title C++ Components for QML
 
 \section1 Making a C++ object available in QML
 
@@ -79,9 +79,9 @@ QML_DEFINE_TYPE(MyLib,1,0,5,Circle,MyCircle);
 would make the \e MyCircle class accessable though the \c Circle type in QML whenever MyLib 1.0 to 1.5 is imported.
 
 
-\section1 Creating a new 'Fx' item in C++
+\section1 Creating a new type of QML item in C++
 
-You can create a new type of 'Fx' item by:
+You can create a new type of QML item by:
 \list 1
 \o Creating a subclass of QFxItem,
 \o Adding Q_PROPERTYs appropriate for your item (see \l {properties}{Properties}),
diff --git a/doc/src/declarative/elements.qdoc b/doc/src/declarative/elements.qdoc
index ffa5494..bfaf4ab 100644
--- a/doc/src/declarative/elements.qdoc
+++ b/doc/src/declarative/elements.qdoc
@@ -29,15 +29,15 @@ The following table lists the QML elements provided by the Qt Declarative module
 \o \l PropertyAnimation
 \o \l NumberAnimation
 \o \l ColorAnimation
-\o \l PauseAnimation
 \o \l SequentialAnimation
 \o \l ParallelAnimation
+\o \l PauseAnimation
 \o \l PropertyAction
 \o \l ParentAction
 \o \l ScriptAction
 \o \l Transition
-\o \l Behavior
 \o \l Follow
+\o \l Behavior
 \endlist
 
 \o
@@ -60,7 +60,7 @@ The following table lists the QML elements provided by the Qt Declarative module
 \endlist
 \endtable
 
-\bold {Fluid UI Primitives}
+\bold {QML Items}
 
 \table 80%
 \header
diff --git a/doc/src/declarative/examples.qdoc b/doc/src/declarative/examples.qdoc
index 31c8a5d..49a825a 100644
--- a/doc/src/declarative/examples.qdoc
+++ b/doc/src/declarative/examples.qdoc
@@ -4,21 +4,21 @@
 \title QML Examples
 
 A \l {qmlviewer}{viewer} application is included that allows you to quickly explore many of the
-examples.  It has some useful options, revealed by:
+examples. It has some useful options, revealed by:
 
 \code
     bin/qmlviewer -help
 \endcode
 
-There are several illustrative QML examples available.  From your build 
-directory, 
+There are several illustrative QML examples available.  From your build
+directory,
 
 \code
     bin/qmlviewer $QT_SOURCE_DIR/demos/declarative/flickr/flickr.qml
 \endcode
 
-Many other simple examples can be found under the \c examples/declarative sub 
-directory.  Some can be run directly using the viewer like those above, and 
+Many other simple examples can be found under the \c examples/declarative sub
+directory.  Some can be run directly using the viewer like those above, and
 others require you to build and run an executable.
 
 More sophisticated demos of large applications can be found under the \c demos/declarative
diff --git a/doc/src/declarative/focus.qdoc b/doc/src/declarative/focus.qdoc
index 5c53483..7c293ee 100644
--- a/doc/src/declarative/focus.qdoc
+++ b/doc/src/declarative/focus.qdoc
@@ -1,21 +1,21 @@
 /*!
 \target qmlfocus
 \page qmlfocus.html
-\title Fluid UI Keyboard Focus 
+\title Keyboard Focus in QML
 
 When a key is pressed or released, a key event is generated and delivered to the
-focused fluid UI \l Item.  To facilitate the construction of reusable components
-and to address some of the cases unique to fluid UIs, the fluid UI atoms add a 
-"scope" based extension to Qt's traditional keyboard focus model.
+focused QML \l Item.  To facilitate the construction of reusable components
+and to address some of the cases unique to fluid user interfaces, the QML items add a
+\e scope based extension to Qt's traditional keyboard focus model.
 
 \section1 Key Handling Overview
 
 When the user presses or releases a key, the following occurs:
 \list 1
 \o Qt receives the key action and generates a key event.
-\o If the Qt widget containing the fluid UI scene has focus, the key event is delivered to the fluid UI scene.  Otherwise, regular Qt key handling continues.
-\o The key event is delivered by the scene to the fluid UI \l Item with \e {active focus}.  If no fluid UI \l Item has \e {active focus}, the key event is \l {QEvent::ignore()}{ignored} and regular Qt key handling continues.
-\o If the fluid UI \l Item with \e {active focus} accepts the key event, propagation stops.  Otherwise the event is "bubbled up", by recursively passing it to each \l Item's parent until either the event is accepted, or the root \l Item is reached.
+\o If the Qt widget containing the \l QFxView has focus, the key event is delivered to it. Otherwise, regular Qt key handling continues.
+\o The key event is delivered by the scene to the QML \l Item with \e {active focus}.  If no \l Item has \e {active focus}, the key event is \l {QEvent::ignore()}{ignored} and regular Qt key handling continues.
+\o If the QML \l Item with \e {active focus} accepts the key event, propagation stops.  Otherwise the event is "bubbled up", by recursively passing it to each \l Item's parent until either the event is accepted, or the root \l Item is reached.
 
 If the \c {Rect} element in the following example has active focus and the \e A key is pressed, it will bubble up to the \c {KeyActions}.  However, pressing the \e B key will bubble up to the root item and thus subsequently be \l {QEvent::ignore()}{ignored}.
 
@@ -34,7 +34,7 @@ Item {
 
 \section1 Querying the Active Focus Item
 
-Whether or not an \l Item has \e {active focus} can be queried through the 
+Whether or not an \l Item has \e {active focus} can be queried through the
 read-only property \c {Item::activeFocus}.  For example, here we have a \l Text
 element whose text is determined by whether or not it has \e {active focus}.
 
@@ -46,7 +46,7 @@ Text {
 
 \section1 Acquiring Focus and Focus Scopes
 
-An \l Item requests focus by setting the \c {Item::focus} property to true.  
+An \l Item requests focus by setting the \c {Item::focus} property to true.
 
 For very simple cases simply setting the \c {Item::focus} property is sometimes
 sufficient.  If we run the following example in the \c qmlviewer, we see that
@@ -74,8 +74,8 @@ However, were the above example to be used as a self-contained component, this
 simple use of the \c {Item::focus} property is no longer sufficient.  The left
 hand side of the following table shows what we would like to be able to write.
 Here we create two instances of our previously defined component, and set the
-second one to have focus.  The intention is that when the \e A, \e B, or \e C 
-keys are pressed, the second of the two components receives the event and 
+second one to have focus.  The intention is that when the \e A, \e B, or \e C
+keys are pressed, the second of the two components receives the event and
 reponds accordingly.
 
 \table
@@ -117,25 +117,25 @@ Rectangle {
 
 The right hand side of the example shows the expanded code - the equivalent QML
 without the use of the component \c {MyWidget}.  From this, the problem is
-evident - there are no less than three elements that have the \c {Item::focus} 
-property set to true.  Ultimately only one element can have focus, and the 
-system has to decide which on.  In this case the first appearance of the 
+evident - there are no less than three elements that have the \c {Item::focus}
+property set to true.  Ultimately only one element can have focus, and the
+system has to decide which on.  In this case the first appearance of the
 \c {Item::focus} property being set to true on line 4 is selected, and the value
 of \c {Item::focus} in the other two instances is reverted back to false.  This
 is exactly the opposite of what was wanted!
 
-This problem is fundamentally one of visibility.  The \c {MyWidget} 
+This problem is fundamentally one of visibility.  The \c {MyWidget}
 components each set their \c {KeyActions} as focused as that is all they can
 do - they don't know how they are going to be used, but they do know that when
 they're in use their \c {KeyActions} element is what needs focus.  Likewise
 the code that uses the \c {MyWidget}'s sets the second \c {MyWidget} as
-focused because, while it doesn't know exactly how the \c {MyWidget} is 
+focused because, while it doesn't know exactly how the \c {MyWidget} is
 implemented, it knows that it wants the second one to be focused.  No one piece
 of code knows everything about the other, which is exactly how it should be.
 
 To solve this problem - allowing components to care about what they know about
-and ignore everything else - the fluid UI atoms introduce a concept known as a 
-\e {focus scope}.  For existing Qt users, a \e {focus scope} is like an 
+and ignore everything else - the QML items introduce a concept known as a
+\e {focus scope}.  For existing Qt users, a \e {focus scope} is like an
 automatic focus proxy.  A \e {focus scope} is created using the \l FocusScope
 element.
 
@@ -162,11 +162,11 @@ FocusScope {
 \o \image declarative-qmlfocus2.png
 \endtable
 
-Conceptually \e {focus scopes} are quite simple.  
+Conceptually \e {focus scopes} are quite simple.
 \list
-\o Within each \e {focus scope} one element may have \c {Item::focus} set to true.  If more than one \l Item has the \c {Item::focus} property set, the first is selected and the others are unset, just like when there are no \e {focus scopes}. 
+\o Within each \e {focus scope} one element may have \c {Item::focus} set to true.  If more than one \l Item has the \c {Item::focus} property set, the first is selected and the others are unset, just like when there are no \e {focus scopes}.
 \o When a \e {focus scope} receives \e {active focus}, the contained element with \c {Item::focus} set (if any) also gets \e {active focus}.  If this element is
-also a \l FocusScope, the proxying behaviour continues.  Both the 
+also a \l FocusScope, the proxying behaviour continues.  Both the
 \e {focus scope} and the sub-focused item will have \c {Item::activeFocus} set.
 \endlist
 
@@ -176,7 +176,7 @@ application.  We still set a one of the widgets as focused by default, but from
 then on clicking the either one gives it focus.
 
 \table
-\row 
+\row
 \o \code
 Rectangle {
     color: "red"; width: 240; height: 55
@@ -195,24 +195,24 @@ FocusScope {
 
 \image declarative-qmlfocus3.png
 
-When a fluid UI atom explicitly relinquishes focus (by setting its 
-\c {Item::focus} property to false while it has \e {active focus}), the system 
+When a QML item explicitly relinquishes focus (by setting its
+\c {Item::focus} property to false while it has \e {active focus}), the system
 does not automatically select another element to receive focus.  That is, it
 is possible for there to be no currently \e {active focus}.
 
 \section1 Advanced uses of Focus Scopes
 
-Focus scopes allow focus to allocation to be easily partitioned.  Several 
-fluid UI atoms use it to this effect.
+Focus scopes allow focus to allocation to be easily partitioned.  Several
+QML items use it to this effect.
 
-\l ListView, for example, is itself a focus scope.  Generally this isn't 
+\l ListView, for example, is itself a focus scope.  Generally this isn't
 noticable as \l ListView doesn't usually have manually added visual children.
-By being a focus scope, \l ListView can focus the current list item without 
+By being a focus scope, \l ListView can focus the current list item without
 worrying about how that will effect the rest of the application.  This allows
 the current item delegate to react to key presses.
 
 This contrived example shows how this works.  Pressing the \c Return key will
-print the name of the current list item.  
+print the name of the current list item.
 
 \table
 \row
@@ -240,22 +240,22 @@ Rectangle {
 
 While the example is simple, there's a lot going on behind the scenes.  Whenever
 the current item changes, the \l ListView sets the delegate's \c {Item::focus}
-property.  As the \l ListView is a \e {focus scope}, this doesn't effect the 
-rest of the application.  However, if the \l ListView itself has 
+property.  As the \l ListView is a \e {focus scope}, this doesn't effect the
+rest of the application.  However, if the \l ListView itself has
 \e {active focus} this causes the delegate itself to receive \e {active focus}.
 In this example, the root element of the delegate is also a \e {focus scope},
 which in turn gives \e {active focus} to the \c {KeyActions} element that
 actually performs the work of handling the \e {Return} key.
 
-All of the fluid UI view classes, such as \l PathView and \l GridView, behave
+All of the QML view classes, such as \l PathView and \l GridView, behave
 in a similar mannor to allow key handling in their respective delegates.
 
 \section1 Focus Panels
 
-Traditional UIs are composed of many top-level windows.  Windows actually 
+Traditional UIs are composed of many top-level windows.  Windows actually
 perform two tasks - they act as the visual bounds for a widget, and they segment
-focus.  Each window has a separate focused widget, that becomes (to mix 
-terminologies) the \e {active focus} widget when the window is the active 
+focus.  Each window has a separate focused widget, that becomes (to mix
+terminologies) the \e {active focus} widget when the window is the active
 window.
 
 ### Focus panels do basically the same thing.
diff --git a/doc/src/declarative/measuring-performance.qdoc b/doc/src/declarative/measuring-performance.qdoc
index 2387335..8c95422 100644
--- a/doc/src/declarative/measuring-performance.qdoc
+++ b/doc/src/declarative/measuring-performance.qdoc
@@ -1,7 +1,7 @@
-/*! 
+/*!
 \page optimizing-performance.html
 \target optimizing-performance
-\title Optimizing Performance
+\title Optimizing Performance in QML
 
 The Qt Declarative module includes several tools to help measure performance.
 
diff --git a/doc/src/declarative/qtprogrammers.qdoc b/doc/src/declarative/qtprogrammers.qdoc
index 6777724..742fc07 100644
--- a/doc/src/declarative/qtprogrammers.qdoc
+++ b/doc/src/declarative/qtprogrammers.qdoc
@@ -1,4 +1,4 @@
-/*
+/*!
 
    INCOMPLETE
 
@@ -51,7 +51,7 @@ QML usage of the item.
 As an example, imagine you wanted a reusable Button item. If you therefore
 decided to write a QFxItem subclass to implement a button,
 just as QToolButton subclasses QWidget for this purpose, following the rule above, your
-"QFxButton" would not have any appearance - just the notions of enabled, triggering, etc.
+\c QFxButton would not have any appearance - just the notions of enabled, triggering, etc.
 
 But there is already an object in Qt that does this: QAction.
 
diff --git a/doc/src/declarative/tutorial.qdoc b/doc/src/declarative/tutorial.qdoc
index 5c855ec..a2a34b9 100644
--- a/doc/src/declarative/tutorial.qdoc
+++ b/doc/src/declarative/tutorial.qdoc
@@ -1,8 +1,8 @@
-/*! 
+/*!
 \page tutorial.html
 \title Tutorial
 
-This tutorial gives an introduction to QML and the Fluid UI atoms. It doesn't cover everything; the emphasis is on teaching the key principles, and features are introduced as needed.
+This tutorial gives an introduction to QML. It doesn't cover everything; the emphasis is on teaching the key principles, and features are introduced as needed.
 
 Chapter one starts with a minimal "Hello world" program and the following chapters introduce new concepts.