diff options
59 files changed, 287 insertions, 314 deletions
diff --git a/examples/quick/accessibility/doc/src/accessibility.qdoc b/examples/quick/accessibility/doc/src/accessibility.qdoc index 9054b5e394..58de9c5683 100644 --- a/examples/quick/accessibility/doc/src/accessibility.qdoc +++ b/examples/quick/accessibility/doc/src/accessibility.qdoc @@ -30,12 +30,11 @@ \brief This example has accessible buttons. \ingroup qtquickexamples - Elements in this example are augmented with meta-data for accessiblity systems. + Types in this example are augmented with meta-data for accessiblity systems. For example, the button identifies itself and its functionality to the accessibility system: \snippet quick/accessibility/content/Button.qml button - As do Text elements inside the example: + As do Text types inside the example: \snippet quick/accessibility/accessibility.qml text */ - diff --git a/examples/quick/animation/doc/src/animation.qdoc b/examples/quick/animation/doc/src/animation.qdoc index 2b41fd71bc..993a4fb01b 100644 --- a/examples/quick/animation/doc/src/animation.qdoc +++ b/examples/quick/animation/doc/src/animation.qdoc @@ -33,7 +33,7 @@ \ingroup qtquickexamples This is a collection of small QML examples relating to animation. Each example is - a small QML file emphasizing a particular element or feature. + a small QML file emphasizing a particular type or feature. ColorAnimation demonstrates using a color animation to fade a sky from day to night. \snippet quick/animation/basics/color-animation.qml 0 @@ -59,7 +59,7 @@ States demonstrates how the properties of an item can vary between states. It defines several states: \snippet quick/animation/states/states.qml 0 - Note that there is also the implicit 'base state' from properties set directly on elements. + Note that there is also the implicit 'base state' from properties set directly on objects. Transitions takes the States example and animates the property changes by setting transitions: \snippet quick/animation/states/transitions.qml 0 diff --git a/examples/quick/canvas/doc/src/canvas.qdoc b/examples/quick/canvas/doc/src/canvas.qdoc index 8da29e2780..099ee174a8 100644 --- a/examples/quick/canvas/doc/src/canvas.qdoc +++ b/examples/quick/canvas/doc/src/canvas.qdoc @@ -33,7 +33,7 @@ \ingroup qtquickexamples This is a collection of small QML examples relating to Canvas item. Each example is - a small QML file emphasizing a particular element or feature. + a small QML file emphasizing a particular type or feature. Red heart demonstrates using a bezierCurve API to stroke and fill a red heart. \snippet quick/canvas/bezierCurve/bezierCurve.qml 0 @@ -56,4 +56,3 @@ \snippet quick/canvas/tiger/tiger.qml 0 */ - diff --git a/examples/quick/doc/src/qml-extending.qdoc b/examples/quick/doc/src/qml-extending.qdoc index 2920398de1..0b032c60fc 100644 --- a/examples/quick/doc/src/qml-extending.qdoc +++ b/examples/quick/doc/src/qml-extending.qdoc @@ -31,17 +31,17 @@ \brief Exporting C++ Classes \ingroup qmlextendingexamples -The Adding Types Example shows how to add a new element type, \c Person, to QML. +The Adding Types Example shows how to add a new object type, \c Person, to QML. The \c Person type can be used from QML like this: \snippet qml/referenceexamples/adding/example.qml 0 \section1 Declare the Person class -All QML elements map to C++ types. Here we declare a basic C++ Person class +All QML types map to C++ types. Here we declare a basic C++ Person class with the two properties we want accessible on the QML type - name and shoeSize. Although in this example we use the same name for the C++ class as the QML -element, the C++ class can be named differently, or appear in a namespace. +type, the C++ class can be named differently, or appear in a namespace. \snippet qml/referenceexamples/adding/person.h 0 @@ -74,7 +74,7 @@ This example builds on: \endlist The Object and List Property Types example shows how to add object and list -properties in QML. This example adds a BirthdayParty element that specifies +properties in QML. This example adds a BirthdayParty type that specifies a birthday party, consisting of a celebrant and a list of guests. People are specified using the People QML type built in the previous example. @@ -125,8 +125,8 @@ This example builds on: \endlist The Inheritance and Coercion Example shows how to use base classes to assign -elements of more than one type to a property. It specializes the Person element -developed in the previous examples into two elements - a \c Boy and a \c Girl. +types of more than one type to a property. It specializes the Person type +developed in the previous examples into two types - a \c Boy and a \c Girl. \snippet qml/referenceexamples/coercion/example.qml 0 @@ -164,7 +164,7 @@ and their QML name with the QML engine. \section1 Running the example -The BirthdayParty element has not changed since the previous example. The +The BirthdayParty type has not changed since the previous example. The celebrant and guests property still use the People type. \snippet qml/referenceexamples/coercion/birthdayparty.h 0 @@ -204,7 +204,7 @@ The only difference between this example and the last, is the addition of the \snippet qml/referenceexamples/default/birthdayparty.h 0 The default property specifies the property to assign to whenever an explicit -property is not specified, in the case of the BirthdayParty element the guest +property is not specified, in the case of the BirthdayParty type the guest property. It is purely a syntactic simplification, the behavior is identical to specifying the property by name, but it can add a more natural feel in many situations. The default property must be either an object or list property. diff --git a/examples/quick/imageelements/doc/src/imageelements.qdoc b/examples/quick/imageelements/doc/src/imageelements.qdoc index abd5f332e5..cae5d20134 100644 --- a/examples/quick/imageelements/doc/src/imageelements.qdoc +++ b/examples/quick/imageelements/doc/src/imageelements.qdoc @@ -27,11 +27,11 @@ /*! \title QML Examples - Image Elements \example quick/imageelements - \brief This is a collection of QML examples relating to image elements. + \brief This is a collection of QML examples relating to image types. \image qml-imageelements-example.png \ingroup qtquickexamples - This is a collection of small QML examples relating to image elements. + This is a collection of small QML examples relating to image types. 'BorderImage' shows off the various scaling modes of the BorderImage item by setting its horizontalTileMode and verticalTileMode properties. @@ -43,7 +43,7 @@ \snippet quick/imageelements/content/ShadowRectangle.qml shadow 'AnimatedSprite' shows how to display a simple animation using an - AnimatedSprite element: + AnimatedSprite object: \snippet quick/imageelements/animatedsprite.qml sprite The sprite animation will loop 3 times. @@ -57,4 +57,3 @@ \snippet quick/imageelements/spritesequence.qml animation At the end of the animation the bear is set back to its initial state. */ - diff --git a/examples/quick/mousearea/doc/src/mousearea.qdoc b/examples/quick/mousearea/doc/src/mousearea.qdoc index 10f92e689e..3e026da374 100644 --- a/examples/quick/mousearea/doc/src/mousearea.qdoc +++ b/examples/quick/mousearea/doc/src/mousearea.qdoc @@ -27,21 +27,20 @@ /*! \title QtQuick Examples - MouseArea \example quick/mousearea - \brief This is an example of the MouseArea element in QML + \brief This is an example of the MouseArea type in QML \image qml-mousearea-example.png \ingroup qtquickexamples This example shows you how to respond to clicks and drags with a MouseArea. - When you click inside the red square, the Text element will list several properties + When you click inside the red square, the Text type will list several properties of that click which are available to QML. Signals are emitted by the MouseArea when clicks or other discrete operations occur within it \snippet quick/mousearea/mousearea.qml clicks - The MouseArea can also be used to drag elements around. By setting the parameters of the drag property, + The MouseArea can also be used to drag items around. By setting the parameters of the drag property, the target item will be dragged around if the user starts to drag within the MouseArea. \snippet quick/mousearea/mousearea.qml drag */ - diff --git a/examples/quick/painteditem/textballoons/doc/src/textballoons.qdoc b/examples/quick/painteditem/textballoons/doc/src/textballoons.qdoc index 6f1d751a5f..fff7f2147d 100644 --- a/examples/quick/painteditem/textballoons/doc/src/textballoons.qdoc +++ b/examples/quick/painteditem/textballoons/doc/src/textballoons.qdoc @@ -62,7 +62,7 @@ To implement a QQuickPaintedItem you must implement QQuickPaintedIem's pure virtual function \l {QQuickPaintedItem::}{paint()} which implements the - painting of the element. + painting of the type. \section1 TextBalloon Class Definition @@ -92,7 +92,7 @@ \snippet quick/customitems/painteditem/textballoons.qml 0 - The balloonModel contains two elements at application start which will be + The balloonModel contains two types at application start which will be displayed by the balloonView. The balloonView alernates the TextBalloon delegate items between left-aligned and right-aligned. @@ -102,7 +102,6 @@ The controls part of the UI contains a rectangle with a MouseArea which changes color when the mouse hovers over it. This control 'button' adds - a new element to the end of the model with a random width. + a new object to the end of the model with a random width. */ - diff --git a/examples/quick/particles/affectors/doc/src/affectors.qdoc b/examples/quick/particles/affectors/doc/src/affectors.qdoc index 977eb8ea95..999afe1509 100644 --- a/examples/quick/particles/affectors/doc/src/affectors.qdoc +++ b/examples/quick/particles/affectors/doc/src/affectors.qdoc @@ -32,7 +32,7 @@ \image qml-affectors-example.png This is a collection of small QML examples relating to using Affectors in the particle system. - Each example is a small QML file emphasizing a particular element or feature. + Each example is a small QML file emphasizing a particular type or feature. Age demonstrates using an Age affector to prematurely end the lives of particles. \snippet quick/particles/affectors/content/age.qml 0 @@ -78,7 +78,7 @@ moves into the lit group after 100ms. \snippet quick/particles/affectors/content/groupgoal.qml lit The lit group also has TrailEmitters on it for additional fire and smoke, but does not transition anywhere. - There are two more GroupGoal elements that allow particles in the unlit group to transition to the lighting group + There are two more GroupGoal objects that allow particles in the unlit group to transition to the lighting group (and then to the lit group). \snippet quick/particles/affectors/content/groupgoal.qml groupgoal-pilot The first is just an area bound to the location of an image of a pilot flame. When unlit balls pass through the flame, @@ -110,4 +110,3 @@ \snippet quick/particles/affectors/content/wander.qml 0 There are different movements given by applying the Wander to different attributes of the trajectory, so the example makes it easy to play around and see the difference. */ - diff --git a/examples/quick/particles/emitters/doc/src/emitters.qdoc b/examples/quick/particles/emitters/doc/src/emitters.qdoc index 5644ab1af3..70a78e92f1 100644 --- a/examples/quick/particles/emitters/doc/src/emitters.qdoc +++ b/examples/quick/particles/emitters/doc/src/emitters.qdoc @@ -31,7 +31,7 @@ \image qml-emitters-example.png This is a collection of small QML examples relating to using Emitters in the particle system. - Each example is a small QML file emphasizing a particular element or feature. + Each example is a small QML file emphasizing a particular type or feature. Velocity from motion gives the effect of strong particle motion through primarily moving the emitters: \snippet quick/particles/emitters/content/velocityfrommotion.qml 0 @@ -54,7 +54,7 @@ \snippet quick/particles/emitters/content/shapeanddirection.qml 0 This sends the particles towards the center of the ellipse with proportional speed, keeping the ellipse outline as they move to the center. - TrailEmitter uses that element to add smoke particles to trail the fire particles in the scene. + TrailEmitter uses that type to add smoke particles to trail the fire particles in the scene. \snippet quick/particles/emitters/content/customemitter.qml 0 */ diff --git a/examples/quick/particles/imageparticle/doc/src/imageparticle.qdoc b/examples/quick/particles/imageparticle/doc/src/imageparticle.qdoc index 1de194b962..ac05124ae0 100644 --- a/examples/quick/particles/imageparticle/doc/src/imageparticle.qdoc +++ b/examples/quick/particles/imageparticle/doc/src/imageparticle.qdoc @@ -32,7 +32,7 @@ \image qml-imageparticle-example.png This is a collection of small QML examples relating to using Affectors in the particle system. - Each example is a small QML file emphasizing a particular element or feature. + Each example is a small QML file emphasizing a particular type or feature. All at once shows off several of the features of ImageParticle at the same time. \snippet quick/particles/imageparticle/content/allatonce.qml 0 diff --git a/examples/quick/particles/system/doc/src/system.qdoc b/examples/quick/particles/system/doc/src/system.qdoc index a01b014f4b..f96ff49937 100644 --- a/examples/quick/particles/system/doc/src/system.qdoc +++ b/examples/quick/particles/system/doc/src/system.qdoc @@ -32,15 +32,15 @@ \image qml-system-example.png This is a collection of small QML examples relating to using Affectors in the particle system. - Each example is a small QML file emphasizing a particular element or feature. + Each example is a small QML file emphasizing a particular type or feature. - Dynamic comparison compares using the particle system to getting a similar effect with the following code that dynamically instantiates Image elements. + Dynamic comparison compares using the particle system to getting a similar effect with the following code that dynamically instantiates Image types. \snippet quick/particles/system/content/dynamiccomparison.qml fake - Note how the Image elements are not able to be randomly colorized. + Note how the Image objects are not able to be randomly colorized. Start and Stop simply sets the running and paused states of a ParticleSystem. While the system does not perform any simulation when stopped or paused, a restart restarts the simulation from the beginning, while unpausing resumes the simulation from where it was. - Timed group changes is an example that highlights the ParticleGroup element. While normally referring to groups with a string name is sufficent, additional effects can be + Timed group changes is an example that highlights the ParticleGroup type. While normally referring to groups with a string name is sufficent, additional effects can be done by setting properties on groups. The first group has a variable duration on it, but always transitions to the second group. \snippet quick/particles/system/content/timedgroupchanges.qml 0 @@ -53,7 +53,6 @@ \snippet quick/particles/system/content/dynamicemitters.qml 0 Note that this effect, a flurry of flying rainbow spears, would be better served with TrailEmitter. It is only done with dynamic emitters in this example to show the concept more simply. - Multiple Painters shows how to control paint ordering of individual particles. While the paint ordering of particles within one ImagePainter is not strictly defined, ImageParticle elements follow the normal Z-ordering rules for QtQuick items. This example allow you to paint the inside of the particles above the black borders using a pair of ImageParticles each painting different parts of the same logical particle. + Multiple Painters shows how to control paint ordering of individual particles. While the paint ordering of particles within one ImagePainter is not strictly defined, ImageParticle objects follow the normal Z-ordering rules for QtQuick items. This example allow you to paint the inside of the particles above the black borders using a pair of ImageParticles each painting different parts of the same logical particle. */ - diff --git a/examples/quick/positioners/doc/src/positioners.qdoc b/examples/quick/positioners/doc/src/positioners.qdoc index 8dd7de193c..d61dc81b30 100644 --- a/examples/quick/positioners/doc/src/positioners.qdoc +++ b/examples/quick/positioners/doc/src/positioners.qdoc @@ -32,7 +32,7 @@ \ingroup qtquickexamples This is a collection of small QML examples relating to positioners. Each example is - a small QML file emphasizing a particular element or feature. + a small QML file emphasizing a particular type or feature. Transitions shows animated transitions when showing or hiding items in a positioner. It consists of a scene populated with items in a variety of positioners: Column, Row, Grid and Flow. @@ -50,4 +50,3 @@ Attached Properties shows how the Positioner attached property can be used to determine where an item is within a positioner. \snippet quick/positioners/positioners-attachedproperties.qml 0 */ - diff --git a/examples/quick/scenegraph/customgeometry/doc/src/customgeometry.qdoc b/examples/quick/scenegraph/customgeometry/doc/src/customgeometry.qdoc index d99deb754f..dbc4d59470 100644 --- a/examples/quick/scenegraph/customgeometry/doc/src/customgeometry.qdoc +++ b/examples/quick/scenegraph/customgeometry/doc/src/customgeometry.qdoc @@ -186,8 +186,8 @@ \snippet quick/scenegraph/customgeometry/main.qml 1 Our .qml file imports the \c {QtQuick 2.0} module to get the - standard elements and also our own \c {CustomGeometry 1.0} module - which contains our newly created BezierCurve element. + standard types and also our own \c {CustomGeometry 1.0} module + which contains our newly created BezierCurve objects. \snippet quick/scenegraph/customgeometry/main.qml 2 @@ -205,4 +205,3 @@ Finally we overlay a short text outlining what the example shows. */ - diff --git a/examples/quick/shadereffects/doc/src/shadereffects.qdoc b/examples/quick/shadereffects/doc/src/shadereffects.qdoc index b8b5459c29..fdc80a05c0 100644 --- a/examples/quick/shadereffects/doc/src/shadereffects.qdoc +++ b/examples/quick/shadereffects/doc/src/shadereffects.qdoc @@ -34,9 +34,9 @@ This example demonstrates a couple of visual effects that you can perform with shaders in QtQuick 2.0 - ShaderEffects typically operate on other elements, using a ShaderEffectSource + ShaderEffects typically operate on other types, using a ShaderEffectSource \snippet quick/shadereffects/shadereffects.qml source - In the above snippet, theItem is the id of a complex QML element in the file. + In the above snippet, theItem is the id of a complex QML object in the file. ShaderEffects can use this ShaderEffectSource as a texture in their fragment shader. \snippet quick/shadereffects/shadereffects.qml fragment @@ -49,4 +49,3 @@ provides more vertices for you to manipulate, enabling many effects. \snippet quick/shadereffects/shadereffects.qml vertex */ - diff --git a/examples/quick/text/doc/src/text.qdoc b/examples/quick/text/doc/src/text.qdoc index fd5d32f5cd..82d142988b 100644 --- a/examples/quick/text/doc/src/text.qdoc +++ b/examples/quick/text/doc/src/text.qdoc @@ -32,18 +32,18 @@ \ingroup qtquickexamples This is a collection of small QML examples relating to text. Each example is - a small QML file, usually containing or emphasizing a particular element or + a small QML file, usually containing or emphasizing a particular type or feature. You can run and observe the behavior of each example. - 'Hello' shows how to change and animate the letter spacing of a Text element. + 'Hello' shows how to change and animate the letter spacing of a Text type. It uses a sequential animation to first animate the font.letterSpacing property from 0 to 50 over 3 seconds and then move the text to a random position on screen: \snippet quick/text/fonts/hello.qml letterspacing - 'Fonts' shows different ways of using fonts with the Text element. + 'Fonts' shows different ways of using fonts with the Text type. Simply by name, using the font.family property directly: \snippet quick/text/fonts/fonts.qml name - or using a FontLoader element: + or using a FontLoader type: \snippet quick/text/fonts/fonts.qml fontloader or using a FontLoader and specifying a local font file: \snippet quick/text/fonts/fonts.qml fontloaderlocal @@ -52,18 +52,18 @@ 'Available Fonts' shows how to use the QML global Qt object and a list view to display all the fonts available on the system. - The ListView element uses the list of fonts available as its model: + The ListView type uses the list of fonts available as its model: \snippet quick/text/fonts/availableFonts.qml model Inside the delegate, the font family is set with the modelData: \snippet quick/text/fonts/availableFonts.qml delegate 'Banner' is a simple example showing how to create a banner using a row of text - elements and a NumberAnimation. + types and a NumberAnimation. - 'Img tag' shows different ways of displaying images in a text elements using + 'Img tag' shows different ways of displaying images in a text types using the <img> tag. - 'Text Layout' shows how to create a more complex layout for a text element. + 'Text Layout' shows how to create a more complex layout for a text item. This example lays out the text in two columns using the onLineLaidOut handler that allows you to position and resize each line: \snippet quick/text/styledtext-layout.qml layout diff --git a/examples/quick/threading/doc/src/threading.qdoc b/examples/quick/threading/doc/src/threading.qdoc index b87cb1b952..3ed8c33c6f 100644 --- a/examples/quick/threading/doc/src/threading.qdoc +++ b/examples/quick/threading/doc/src/threading.qdoc @@ -44,6 +44,6 @@ \snippet quick/threading/workerscript/workerscript.qml 0 The workerscript then is free to take a really long time to calculate it: \snippet quick/threading/workerscript/workerscript.js 0 - When it's done, the result returns to the main scene via the WorkerScript element: + When it's done, the result returns to the main scene via the WorkerScript type: \snippet quick/threading/workerscript/workerscript.qml 1 */ diff --git a/examples/quick/touchinteraction/doc/src/touchinteraction.qdoc b/examples/quick/touchinteraction/doc/src/touchinteraction.qdoc index 54f94383e4..8515b14abf 100644 --- a/examples/quick/touchinteraction/doc/src/touchinteraction.qdoc +++ b/examples/quick/touchinteraction/doc/src/touchinteraction.qdoc @@ -47,10 +47,9 @@ to user input. \snippet quick/touchinteraction/pincharea/flickresize.qml 0 - Flickable is a simple example demonstrating the Flickable element. The element inside the flickable is very big, but the flickable itself is very small: + Flickable is a simple example demonstrating the Flickable type. The object inside the flickable is very big, but the flickable itself is very small: \snippet quick/touchinteraction/flickable/basic-flickable.qml 0 - Corkboards shows a more complex Flickable usecase, with elements on the flickable that respond to mouse and keyboard interaction. - This doesn't require special code, the QtQuick elements automatically cooperate with Flickable for accepting the touch events. + Corkboards shows a more complex Flickable usecase, with types on the flickable that respond to mouse and keyboard interaction. + This doesn't require special code, the Qt Quick types automatically cooperate with Flickable for accepting the touch events. */ - diff --git a/examples/quick/ui-components/slideswitch/doc/src/example-slideswitch.qdoc b/examples/quick/ui-components/slideswitch/doc/src/example-slideswitch.qdoc index 6ec2360287..1ebe7eb9f5 100644 --- a/examples/quick/ui-components/slideswitch/doc/src/example-slideswitch.qdoc +++ b/examples/quick/ui-components/slideswitch/doc/src/example-slideswitch.qdoc @@ -36,7 +36,7 @@ This example shows how to create a reusable switch component in QML. The code for this example can be found in the \c examples/quick/ui-components/slideswitch directory. -The elements that compose the switch are: +The objects that compose the switch are: \list \li a \c on property (the interface to interact with the switch), diff --git a/examples/quick/views/doc/src/views.qdoc b/examples/quick/views/doc/src/views.qdoc index 658e51c8fc..d79f9b0b3e 100644 --- a/examples/quick/views/doc/src/views.qdoc +++ b/examples/quick/views/doc/src/views.qdoc @@ -34,7 +34,7 @@ This is a collection of small QML examples relating to model and view functionality. They demonstrate how to show data from a model using the QtQuick view types. - \section2 GridView and PathView demonstrate usage of these elements to display views. + \section2 GridView and PathView demonstrate usage of these types to display views. \snippet quick/views/gridview/gridview-example.qml 0 \section2 Dynamic List demonstrates animation of runtime additions and removals to a ListView. @@ -80,4 +80,3 @@ \snippet quick/views/visualitemmodel/visualitemmodel.qml 0 */ - diff --git a/src/imports/testlib/signalspy.qdoc b/src/imports/testlib/signalspy.qdoc index a11572740c..0bb1569190 100644 --- a/src/imports/testlib/signalspy.qdoc +++ b/src/imports/testlib/signalspy.qdoc @@ -48,7 +48,7 @@ \ingroup qtest::qml In the following example, a SignalSpy is installed to watch the - "clicked" signal on a user-defined Button element. When the signal + "clicked" signal on a user-defined Button type. When the signal is emitted, the \l count property on the spy will be increased. \code diff --git a/src/imports/testlib/testcase.qdoc b/src/imports/testlib/testcase.qdoc index 1abfdf9629..64fa42d579 100644 --- a/src/imports/testlib/testcase.qdoc +++ b/src/imports/testlib/testcase.qdoc @@ -50,7 +50,7 @@ \section1 Introduction to QML test cases Test cases are written as JavaScript functions within a TestCase - element: + type: \code import QtQuick 2.0 @@ -92,7 +92,7 @@ the test framework will sort the functions on ascending order of name. This can help when there are two tests that must be run in order. - Multiple TestCase elements can be supplied. The test program will exit + Multiple TestCase types can be supplied. The test program will exit once they have all completed. If a test case doesn't need to run (because a precondition has failed), then \l optional can be set to true. @@ -100,7 +100,7 @@ Table data can be provided to a test using a function name that ends with "_data". Alternatively, the \c init_data() function can be used - to provide default test data for all test functions in a TestCase element: + to provide default test data for all test functions in a TestCase type: \code @@ -251,9 +251,9 @@ } \endcode - The test application will exit once all \l TestCase elements + The test application will exit once all \l TestCase types have been triggered and have run. The \l optional property can - be used to exclude a \l TestCase element. + be used to exclude a \l TestCase type. \sa optional, completed */ @@ -261,7 +261,7 @@ /*! \qmlproperty bool TestCase::optional - Multiple \l TestCase elements can be supplied in a test application. + Multiple \l TestCase types can be supplied in a test application. The application will exit once they have all completed. If a test case does not need to run (because a precondition has failed), then this property can be set to true. The default value is false. @@ -305,7 +305,7 @@ This property will be set to true after the QML viewing window has been displayed. Normally test cases run as soon as the test application is loaded and before a window is displayed. If the test case involves - visual elements and behaviors, then it may need to be delayed until + visual types and behaviors, then it may need to be delayed until after the window is shown. \code @@ -647,7 +647,7 @@ \qmlmethod TestCase::initTestCase() This function is called before any other test functions in the - \l TestCase element. The default implementation does nothing. + \l TestCase type. The default implementation does nothing. The application can provide its own implementation to perform test case initialization. @@ -658,7 +658,7 @@ \qmlmethod TestCase::cleanupTestCase() This function is called after all other test functions in the - \l TestCase element have completed. The default implementation + \l TestCase type have completed. The default implementation does nothing. The application can provide its own implementation to perform test case cleanup. @@ -669,7 +669,7 @@ \qmlmethod TestCase::init() This function is called before each test function that is - executed in the \l TestCase element. The default implementation + executed in the \l TestCase type. The default implementation does nothing. The application can provide its own implementation to perform initialization before each test function. @@ -680,7 +680,7 @@ \qmlmethod TestCase::cleanup() This function is called after each test function that is - executed in the \l TestCase element. The default implementation + executed in the \l TestCase type. The default implementation does nothing. The application can provide its own implementation to perform cleanup after each test function. diff --git a/src/qml/doc/src/cppintegration/contextproperties.qdoc b/src/qml/doc/src/cppintegration/contextproperties.qdoc index b40eec7f6e..aaac43e470 100644 --- a/src/qml/doc/src/cppintegration/contextproperties.qdoc +++ b/src/qml/doc/src/cppintegration/contextproperties.qdoc @@ -77,7 +77,7 @@ QML code invokes a method on the object instance: \l{QML:Qt::formatDateTime}{Qt.formatDateTime()} and associated functions.) If the QML item needs to receive signals from the context property, it can connect to them using the -\l Connections element. For example, if \c ApplicationData has a signal named \c +\l Connections type. For example, if \c ApplicationData has a signal named \c dataChanged(), this signal can be connected to using an \c onDataChanged handler within a \l Connections object: diff --git a/src/qml/doc/src/cppintegration/definetypes.qdoc b/src/qml/doc/src/cppintegration/definetypes.qdoc index 84eb4bb2cd..be5f26a865 100644 --- a/src/qml/doc/src/cppintegration/definetypes.qdoc +++ b/src/qml/doc/src/cppintegration/definetypes.qdoc @@ -168,7 +168,7 @@ are constructed and owned by the QQmlEngine, and will be destroyed when the engine is destroyed. A QObject singleton type can be interacted with in a manner simlar to any -other QObject or instantiated element, except that only one (engine constructed +other QObject or instantiated type, except that only one (engine constructed and owned) instance will exist, and it must be referenced by type name rather than id. Q_PROPERTYs of QObject singleton types may be bound to, and Q_INVOKABLE functions of QObject module APIs may be used in signal handler expressions. @@ -230,7 +230,7 @@ version of their type definition, \c root.x now resolves to a different value because \c root is also the \c id of the top level component. The author could specify that the new \c root property is available from a specific minor version. This permits new properties and features to be added to existing -elements without breaking existing programs. +types without breaking existing programs. The REVISION tag is used to mark the \c root property as added in revision 1 of the type. Methods such as Q_INVOKABLE's, signals and slots can also be @@ -263,7 +263,7 @@ qmlRegisterType<CppType,1>("MyTypes", 1, 1, "CppType") \c root is only available when \c MyTypes version 1.1 is imported. -For the same reason, new elements introduced in later versions should use +For the same reason, new types introduced in later versions should use the minor version argument of qmlRegisterType. This feature of the language allows for behavioural changes to be made diff --git a/src/qml/doc/src/cppintegration/extending-tutorial.qdoc b/src/qml/doc/src/cppintegration/extending-tutorial.qdoc index 63c06e2706..247e60411f 100644 --- a/src/qml/doc/src/cppintegration/extending-tutorial.qdoc +++ b/src/qml/doc/src/cppintegration/extending-tutorial.qdoc @@ -69,7 +69,7 @@ and \l {qtqml-cppintegration-definetypes.html}{Defining QML Types from C++}. A common task when extending QML is to provide a new QML type that supports some custom functionality beyond what is provided by the built-in \l {Qt Quick QML Types}{QtQuick types}. For example, this could be done to implement particular data models, or provide -elements with custom painting and drawing capabilities, or access system features +types with custom painting and drawing capabilities, or access system features like network programming that are not accessible through built-in QML features. In this tutorial, we will show how to use the C++ classes in the Qt Declarative @@ -210,8 +210,8 @@ Try out the example yourself with the updated code in Qt's \c examples/quick/tut \example quick/tutorials/extending/chapter3-bindings Property binding is a powerful feature of QML that allows values of different -elements to be synchronized automatically. It uses signals to notify and update -other elements' values when property values are changed. +types to be synchronized automatically. It uses signals to notify and update +other types' values when property values are changed. Let's enable property bindings for the \c color property. That means if we have code like this: @@ -245,7 +245,7 @@ Then, we emit this signal in \c setPieSlice(): It's important for \c setColor() to check that the color value has actually changed before emitting \c colorChanged(). This ensures the signal is not emitted unnecessarily and -also prevents loops when other elements respond to the value change. +also prevents loops when other types respond to the value change. The use of bindings is essential to QML. You should always add NOTIFY signals for properties if they are able to be implemented, so that your diff --git a/src/qml/doc/src/cppintegration/interactqmlfromcpp.qdoc b/src/qml/doc/src/cppintegration/interactqmlfromcpp.qdoc index 04b278106f..15d98ec405 100644 --- a/src/qml/doc/src/cppintegration/interactqmlfromcpp.qdoc +++ b/src/qml/doc/src/cppintegration/interactqmlfromcpp.qdoc @@ -143,7 +143,7 @@ or QObject::setProperty() and QObject::property(): You should always use QObject::setProperty(), QQmlProperty or QMetaProperty::write() to change a QML property value, to ensure the QML engine is made aware of the property change. For example, say you have a -custom element \c PushButton with a \c buttonText property that internally +custom type \c PushButton with a \c buttonText property that internally reflects the value of a \c m_buttonText member variable. Modifying the member variable directly like this is not a good idea: diff --git a/src/qml/doc/src/documents/scope.qdoc b/src/qml/doc/src/documents/scope.qdoc index e72b07d092..9da77a4905 100644 --- a/src/qml/doc/src/documents/scope.qdoc +++ b/src/qml/doc/src/documents/scope.qdoc @@ -74,11 +74,11 @@ Every JavaScript expression, function or file in QML has its own unique variable object. Local variables declared in one will never conflict with local variables declared in another. -\section1 Element Names and Imported JavaScript Files +\section1 Type Names and Imported JavaScript Files -\l {QML Document}s include import statements that define the element names +\l {QML Document}s include import statements that define the type names and JavaScript files visible to the document. In addition to their use in the -QML declaration itself, element names are used by JavaScript code when accessing +QML declaration itself, type names are used by JavaScript code when accessing \l {Attached Properties} and enumeration values. The effect of an import applies to every property binding, and JavaScript @@ -130,10 +130,10 @@ Consequently unqualified attached property reads will always resolve to an attached property on the scope object, which is not always what the programmer intended. -For example, the \l PathView element attaches interpolated value properties to +For example, the \l PathView type attaches interpolated value properties to its delegates depending on their position in the path. As PathView only -meaningfully attaches these properties to the root element in the delegate, any -sub-element that accesses them must explicitly qualify the root object, as shown +meaningfully attaches these properties to the root object in the delegate, any +sub-object that accesses them must explicitly qualify the root object, as shown below. \code @@ -149,7 +149,7 @@ PathView { } \endcode -If the \l Image element omitted the \c root prefix, it would inadvertently access +If the \l Image object omitted the \c root prefix, it would inadvertently access the unset \c {PathView.scale} attached property on itself. \section1 Component Scope @@ -157,21 +157,21 @@ the unset \c {PathView.scale} attached property on itself. Each QML component in a QML document defines a logical scope. Each document has at least one root component, but can also have other inline sub-components. The component scope is the union of the object ids within the component and the -component's root element's properties. +component's root object's properties. \code Item { property string title Text { - id: titleElement + id: title text: "<b>" + title + "</b>" font.pixelSize: 22 anchors.top: parent.top } Text { - text: titleElement.text + text: title.text font.pixelSize: 18 anchors.bottom: parent.bottom } @@ -180,15 +180,15 @@ Item { The example above shows a simple QML component that displays a rich text title string at the top, and a smaller copy of the same text at the bottom. The first -\c Text element directly accesses the component's \c title property when -forming the text to display. That the root element's properties are directly +\c Text type directly accesses the component's \c title property when +forming the text to display. That the root type's properties are directly accessible makes it trivial to distribute data throughout the component. -The second \c Text element uses an id to access the first's text directly. IDs +The second \c Text type uses an id to access the first's text directly. IDs are specified explicitly by the QML programmer so they always take precedence over other property names (except for those in the \l {JavaScript Scope}). For example, in the unlikely event that the binding's \l {Binding Scope Object}{scope -object} had a \c titleElement property in the previous example, the \c titleElement +object} had a \c titletype property in the previous example, the \c titletype id would still take precedence. \section1 Component Instance Hierarchy @@ -215,13 +215,13 @@ Item { \endcode The component instance hierarchy allows instances of the delegate component -to access the \c defaultColor property of the \c Item element. Of course, +to access the \c defaultColor property of the \c Item type. Of course, had the delegate component had a property called \c defaultColor that would have taken precedence. The component instance scope hierarchy extends to out-of-line components, too. In the following example, the \c TitlePage.qml component creates two -\c TitleText instances. Even though the \c TitleText element is in a separate +\c TitleText instances. Even though the \c TitleText type is in a separate file, it still has access to the \c title property when it is used from within the \c TitlePage. QML is a dynamically scoped language - depending on where it is used, the \c title property may resolve differently. @@ -341,7 +341,7 @@ will refer to one or the other, but not both. \section1 JavaScript Global Object -QML disallows element, id and property names that conflict with the properties +QML disallows type, id and property names that conflict with the properties on the global object to prevent any confusion. Programmers can be confident that \c Math.min(10, 9) will always work as expected! diff --git a/src/qml/doc/src/javascript/expressions.qdoc b/src/qml/doc/src/javascript/expressions.qdoc index a90d794864..a8e6fc8ac0 100644 --- a/src/qml/doc/src/javascript/expressions.qdoc +++ b/src/qml/doc/src/javascript/expressions.qdoc @@ -142,7 +142,7 @@ QML object types can emit signals in reaction to certain events occurring. Those signals can be handled by signal handler functions, which can be defined by clients to implement custom program logic. -Suppose that a button represented by a Rectangle element has a MouseArea and a +Suppose that a button represented by a Rectangle type has a MouseArea and a Text label. The MouseArea will emit its "pressed" signal when the user presses the defined interactive area, which will automatically trigger the \l{MouseArea::}{onPressed} handler, which can be defined by clients. The QML diff --git a/src/qml/doc/src/javascript/hostenvironment.qdoc b/src/qml/doc/src/javascript/hostenvironment.qdoc index 7a517c77d5..a63ef617c0 100644 --- a/src/qml/doc/src/javascript/hostenvironment.qdoc +++ b/src/qml/doc/src/javascript/hostenvironment.qdoc @@ -144,7 +144,7 @@ The \c this keyword is supported when binding properties from JavaScript. In all other situations, the value of \c this is undefined in QML. -To refer to any element, provide an \c id. For example: +To refer to a specific object, provide an \c id. For example: \qml Item { diff --git a/src/qml/doc/src/modules/cppplugins.qdoc b/src/qml/doc/src/modules/cppplugins.qdoc index a5fbafbdfc..af2a36c903 100644 --- a/src/qml/doc/src/modules/cppplugins.qdoc +++ b/src/qml/doc/src/modules/cppplugins.qdoc @@ -65,7 +65,7 @@ \section1 Plugin Example Suppose there is a new \c TimeModel C++ class that should be made available - as a new QML element. It provides the current time through \c hour and \c minute + as a new QML type. It provides the current time through \c hour and \c minute properties. \snippet qml/plugins/plugin.cpp 0 diff --git a/src/qml/doc/src/qmlfunctions.qdoc b/src/qml/doc/src/qmlfunctions.qdoc index 81b8fd594f..4a4de0531c 100644 --- a/src/qml/doc/src/qmlfunctions.qdoc +++ b/src/qml/doc/src/qmlfunctions.qdoc @@ -289,7 +289,7 @@ of the given type T as a singleton type. A QObject singleton type may be referenced via the type name with which it was registered, and this - typename may be used as the target in a \l Connections element or otherwise used as any other element id would. + typename may be used as the target in a \l Connections type or otherwise used as any other type id would. One exception to this is that a QObject singleton type property may not be aliased (because the singleton type name does not identify an object within the same component as any other item). diff --git a/src/qml/doc/src/typesystem/basictypes.qdoc b/src/qml/doc/src/typesystem/basictypes.qdoc index f8b050e7fe..6f468d42bc 100644 --- a/src/qml/doc/src/typesystem/basictypes.qdoc +++ b/src/qml/doc/src/typesystem/basictypes.qdoc @@ -132,7 +132,7 @@ property is only invoked when the property is reassigned to a different object v The \c int type refers to a whole number, e.g. 0, 10, or -20. The possible \c int values range from around -2000000000 to around 2000000000, - although most elements will only accept a reduced range (which they + although most types will only accept a reduced range (which they mention in their documentation). Example: @@ -673,4 +673,3 @@ property is only invoked when the property is reassigned to a different object v \sa {QML Basic Types} */ - diff --git a/src/quick/doc/src/advtutorial.qdoc b/src/quick/doc/src/advtutorial.qdoc index 5e7affc5ed..889bfd8914 100644 --- a/src/quick/doc/src/advtutorial.qdoc +++ b/src/quick/doc/src/advtutorial.qdoc @@ -47,7 +47,7 @@ manage components and enhance your interface, and storing persistent application An understanding of JavaScript is helpful to understand parts of this tutorial, but if you don't know JavaScript you can still get a feel for how you can integrate backend logic to create and -control QML elements. +control QML types. Tutorial chapters: @@ -92,13 +92,13 @@ One item you may not recognize here is the \l SystemPalette item. This provides access to the Qt system palette and is used to give the button a more native look-and-feel. -Notice the anchors for the \c Item, \c Button and \c Text elements are set using +Notice the anchors for the \c Item, \c Button and \c Text types are set using \l {qdeclarativeintroduction.html#dot-properties}{group notation} for readability. \section2 Adding \c Button and \c Block components The \c Button item in the code above is defined in a separate component file named \c Button.qml. -To create a functional button, we use the QML elements \l Text and \l MouseArea inside a \l Rectangle. +To create a functional button, we use the QML types \l Text and \l MouseArea inside a \l Rectangle. Here is the \c Button.qml code: \snippet quick/tutorials/samegame/samegame1/Button.qml 0 @@ -123,13 +123,13 @@ This means that when we dynamically create and resize the block items later on in the tutorial, the image will be scaled automatically to the correct size. -Notice the relative path for the Image element's \c source property. -This path is relative to the location of the file that contains the \l Image element. +Notice the relative path for the Image type's \c source property. +This path is relative to the location of the file that contains the \l Image type. Alternatively, you could set the Image source to an absolute file path or a URL that contains an image. You should be familiar with the code so far. We have just created some basic -elements to get started. Next, we will populate the game canvas with some blocks. +types to get started. Next, we will populate the game canvas with some blocks. */ @@ -145,7 +145,7 @@ elements to get started. Next, we will populate the game canvas with some blocks \section2 Generating the blocks in JavaScript -Now that we've written some basic elements, let's start writing the game. +Now that we've written some types, let's start writing the game. The first task is to generate the game blocks. Each time the New Game button is clicked, the game canvas is populated with a new, random set of @@ -169,7 +169,7 @@ and moves the new block to its position on the game canvas. This involves severa \list \li \l {QML:Qt::createComponent()}{Qt.createComponent()} is called to - generate an element from \c Block.qml. If the component is ready, + generate a type from \c Block.qml. If the component is ready, we can call \c createObject() to create an instance of the \c Block item. @@ -235,11 +235,11 @@ To do this, we have added the following functions to \c samegame.js: \li \c{floodMoveCheck(xIdx, yIdx, type)} \endlist -As this is a tutorial about QML, not game design, we will only discuss \c handleClick() and \c victoryCheck() below since they interface directly with the QML elements. Note that although the game logic here is written in JavaScript, it could have been written in C++ and then exposed to QML. +As this is a tutorial about QML, not game design, we will only discuss \c handleClick() and \c victoryCheck() below since they interface directly with the QML types. Note that although the game logic here is written in JavaScript, it could have been written in C++ and then exposed to QML. \section3 Enabling mouse click interaction -To make it easier for the JavaScript code to interface with the QML elements, we have added an Item called \c gameCanvas to \c samegame.qml. It replaces the background as the item which contains the blocks. It also accepts mouse input from the user. Here is the item code: +To make it easier for the JavaScript code to interface with the QML types, we have added an Item called \c gameCanvas to \c samegame.qml. It replaces the background as the item which contains the blocks. It also accepts mouse input from the user. Here is the item code: \snippet quick/tutorials/samegame/samegame3/samegame.qml 1 @@ -263,7 +263,7 @@ When the player clicks a block and triggers \c handleClick(), \c handleClick() a This updates the \c gameCanvas.score value and displays a "Game Over" dialog if the game is finished. -The Game Over dialog is created using a \c Dialog element that is defined in \c Dialog.qml. Here is the \c Dialog.qml code. Notice how it is designed to be usable imperatively from the script file, via the functions and signals: +The Game Over dialog is created using a \c Dialog type that is defined in \c Dialog.qml. Here is the \c Dialog.qml code. Notice how it is designed to be usable imperatively from the script file, via the functions and signals: \snippet quick/tutorials/samegame/samegame3/Dialog.qml 0 @@ -319,7 +319,7 @@ In anticipation of the new block animations, \c Block.qml file is now renamed to \section3 Animating block movement First we will animate the blocks so that they move in a fluid manner. QML has a number of methods for adding fluid -movement, and in this case we're going to use the \l Behavior element to add a \l SpringAnimation. +movement, and in this case we're going to use the \l Behavior type to add a \l SpringAnimation. In \c BoomBlock.qml, we apply a \l SpringAnimation behavior to the \c x and \c y properties so that the block will follow and animate its movement in a spring-like fashion towards the specified position (whose values will be set by \c samegame.js).Here is the code added to \c BoomBlock.qml: @@ -335,18 +335,18 @@ from the top in rows. (Try commenting out \c {enabled: spawned} and see for your \section3 Animating block opacity changes -Next, we will add a smooth exit animation. For this, we'll use a \l Behavior element, which allows us to specify +Next, we will add a smooth exit animation. For this, we'll use a \l Behavior type, which allows us to specify a default animation when a property change occurs. In this case, when the \c opacity of a Block changes, we will animate the opacity value so that it gradually fades in and out, instead of abruptly changing between fully visible and invisible. To do this, we'll apply a \l Behavior on the \c opacity property of the \c Image -element in \c BoomBlock.qml: +type in \c BoomBlock.qml: \snippet quick/tutorials/samegame/samegame4/content/BoomBlock.qml 2 Note the \c{opacity: 0} which means the block is transparent when it is first created. We could set the opacity in \c samegame.js when we create and destroy the blocks, but instead we'll use \l{Qt Quick States}{states}, since this is useful for the next animation we're going to add. -Initially, we add these States to the root element of \c{BoomBlock.qml}: +Initially, we add these States to the root type of \c{BoomBlock.qml}: \code property bool dying: false states: [ @@ -371,7 +371,7 @@ Finally, we'll add a cool-looking particle effect to the blocks when they are de To fully understand this you should read the \l Particles documentation, but it's important to note that \c emitRate is set to zero so that particles are not emitted normally. -Also, we extend the \c dying State, which creates a burst of particles by calling the \c burst() method on the particles element. The code for the states now look +Also, we extend the \c dying State, which creates a burst of particles by calling the \c burst() method on the particles type. The code for the states now look like this: \snippet quick/tutorials/samegame/samegame4/content/BoomBlock.qml 4 @@ -388,7 +388,7 @@ The theme change here is produced simply by replacing the block images. This can Another feature we might want to add to the game is a method of storing and retrieving high scores. To do this, we will show a dialog when the game is over to request the player's name and add it to a High Scores table. -This requires a few changes to \c Dialog.qml. In addition to a \c Text element, it now has a +This requires a few changes to \c Dialog.qml. In addition to a \c Text type, it now has a \c TextInput child item for receiving keyboard text input: \snippet quick/tutorials/samegame/samegame4/content/Dialog.qml 0 @@ -399,7 +399,7 @@ This requires a few changes to \c Dialog.qml. In addition to a \c Text element, We'll also add a \c showWithInput() function. The text input will only be visible if this function is called instead of \c show(). When the dialog is closed, it emits a \c closed() signal, and -other elements can retrieve the text entered by the user through an \c inputText property: +other types can retrieve the text entered by the user through an \c inputText property: \snippet quick/tutorials/samegame/samegame4/content/Dialog.qml 0 \snippet quick/tutorials/samegame/samegame4/content/Dialog.qml 1 @@ -450,7 +450,7 @@ or QML from the web service to display the high scores. We don't worry about the score data to the web server. If it had returned a QML file (or a URL to a QML file) you could instantiate it in much the same way as you did with the blocks. -An alternate way to access and submit web-based data would be to use QML elements designed for this purpose. XmlListModel +An alternate way to access and submit web-based data would be to use QML types designed for this purpose. XmlListModel makes it very easy to fetch and display XML based data such as RSS in a QML application (see the Flickr demo for an example). @@ -459,7 +459,7 @@ makes it very easy to fetch and display XML based data such as RSS in a QML appl By following this tutorial you've seen how you can write a fully functional application in QML: \list -\li Build your application with \l {QML Types provided by the QtQuick Module}{QML elements} +\li Build your application with \l {QML Types provided by the QtQuick Module}{QML types} \li Add application logic \l{Using JavaScript Expressions in QML}{with JavaScript code} \li Add animations with \l {Behavior}{Behaviors} and \l{Qt Quick States}{states} \li Store persistent application data using, for example, \l{QtQuick.LocalStorage 2}{QtQuick.LocalStorage} or \l XMLHttpRequest diff --git a/src/quick/doc/src/appdevguide/applicationdevelopers.qdoc b/src/quick/doc/src/appdevguide/applicationdevelopers.qdoc index a1d84735b7..0b9af98083 100644 --- a/src/quick/doc/src/appdevguide/applicationdevelopers.qdoc +++ b/src/quick/doc/src/appdevguide/applicationdevelopers.qdoc @@ -83,7 +83,7 @@ QML code is used in applications. \section1 Features And Use-Case Solutions \list -\li \l{qtquick-usecase-visual.html}{Visual Elements in QML} +\li \l{qtquick-usecase-visual.html}{Visual types in QML} \li \l{qtquick-usecase-userinput.html}{Responding to User Input in QML} \li \l{qtquick-usecase-animations.html}{Animations in QML} \li \l{qtquick-usecase-text.html}{Displaying Text in QML} @@ -110,7 +110,7 @@ For in-depth information about the QML language, please see the \section2 What is Qt Quick? Qt Quick is the standard library of types and functionality for QML. It -includes visual elements, interactive elements, animations, models and views, +includes visual types, interactive types, animations, models and views, particle effects and shader effects. A QML application developer can get access to all of that functionality with a single import statement. diff --git a/src/quick/doc/src/appdevguide/codingconventions.qdoc b/src/quick/doc/src/appdevguide/codingconventions.qdoc index b48c5e8a7a..385c00d2a6 100644 --- a/src/quick/doc/src/appdevguide/codingconventions.qdoc +++ b/src/quick/doc/src/appdevguide/codingconventions.qdoc @@ -104,12 +104,3 @@ For long scripts, we will put the functions in their own JavaScript file and imp \snippet qml/codingconventions/javascript-imports.qml 0 */ - - - - - - - - - diff --git a/src/quick/doc/src/appdevguide/deployment.qdoc b/src/quick/doc/src/appdevguide/deployment.qdoc index bf98902c17..1c8bd20c4d 100644 --- a/src/quick/doc/src/appdevguide/deployment.qdoc +++ b/src/quick/doc/src/appdevguide/deployment.qdoc @@ -33,8 +33,8 @@ QML documents are loaded and executed by the QML runtime. This includes the -Declarative UI engine along with the built-in QML elements and plugin modules, -and it also provides access to third-party QML elements and modules. +Declarative UI engine along with the built-in QML types and plugin modules, +and it also provides access to third-party QML types and modules. Applications that use QML need to invoke the QML runtime in order to execute QML documents. This can be done by creating a QQuickView diff --git a/src/quick/doc/src/appdevguide/glossary.qdoc b/src/quick/doc/src/appdevguide/glossary.qdoc index 5ebdca96cc..2ece38256f 100644 --- a/src/quick/doc/src/appdevguide/glossary.qdoc +++ b/src/quick/doc/src/appdevguide/glossary.qdoc @@ -184,7 +184,7 @@ \li Lazy Instantiation \li Object instances can be instantiated "lazily" at run-time, to avoid performing unnecessary work until needed. Qt Quick - provides the \l Loader element to make lazy instantiation more + provides the \l Loader type to make lazy instantiation more convenient. \endtable diff --git a/src/quick/doc/src/appdevguide/internationalization.qdoc b/src/quick/doc/src/appdevguide/internationalization.qdoc index bf6b667a01..9c3e9d9cfb 100644 --- a/src/quick/doc/src/appdevguide/internationalization.qdoc +++ b/src/quick/doc/src/appdevguide/internationalization.qdoc @@ -34,7 +34,7 @@ \section1 Internationalizing your Application The following sections describe various aspects of internationalizing your QML -source code. If you follow these guides for all the user interface elements in +source code. If you follow these guides for all the user interface components in your application, it becomes possible to localize every aspect of your application for different languages and local cultural conventions such as the way dates and numbers are formatted. @@ -278,4 +278,3 @@ SOURCES = *.qml \ See the \l {Qt Linguist Manual} for more details about Qt localization. */ - diff --git a/src/quick/doc/src/appdevguide/performance.qdoc b/src/quick/doc/src/appdevguide/performance.qdoc index 4f0590d554..28217e06d6 100644 --- a/src/quick/doc/src/appdevguide/performance.qdoc +++ b/src/quick/doc/src/appdevguide/performance.qdoc @@ -128,14 +128,14 @@ sorts of optimizations. \section2 Type-Conversion One major cost of using JavaScript is that in most cases when a property from a QML -element is accessed, a JavaScript object with an external resource containing the +type is accessed, a JavaScript object with an external resource containing the underlying C++ data (or a reference to it) is created. In most cases, this is fairly inexpensive, but in others it can be quite expensive. One example of where it is expensive is assigning a C++ QVariantMap Q_PROPERTY to a QML "variant" property. Lists can also be expensive, although sequences of specific types (QList of int, qreal, bool, QString, and QUrl) should be inexpensive; other list types involve an -expensive conversion cost (creating a new JavaScript Array, and adding new elements -one by one, with per-element conversion from C++ type instance to JavaScript value). +expensive conversion cost (creating a new JavaScript Array, and adding new types +one by one, with per-type conversion from C++ type instance to JavaScript value). Converting between some basic property types (such as "string" and "url" properties) can also be expensive. Using the closest matching property type will avoid unnecessary @@ -156,7 +156,7 @@ possible. In the following example, we have a block of code which is run often (in this case, it is the contents of an explicit loop; but it could be a commonly-evaluated binding expression, -for example) and in it, we resolve the element with the "rect" id and its "color" property +for example) and in it, we resolve the object with the "rect" id and its "color" property multiple times: \qml diff --git a/src/quick/doc/src/appdevguide/qtquicktest.qdoc b/src/quick/doc/src/appdevguide/qtquicktest.qdoc index f6085764be..e26cf10a84 100644 --- a/src/quick/doc/src/appdevguide/qtquicktest.qdoc +++ b/src/quick/doc/src/appdevguide/qtquicktest.qdoc @@ -36,7 +36,7 @@ QtQuickTest is a unit test framework for QML applications. Test cases are written as JavaScript functions within a TestCase - element: + type: \code import QtQuick 2.0 @@ -57,7 +57,7 @@ Functions whose names start with \c{test_} are treated as test cases to be executed. See the documentation for the \l TestCase and - \l SignalSpy elements for more information on writing test cases. + \l SignalSpy types for more information on writing test cases. \section1 Running tests diff --git a/src/quick/doc/src/appdevguide/quickstart/essentials.qdoc b/src/quick/doc/src/appdevguide/quickstart/essentials.qdoc index d061d795a5..d7a9ec3cdb 100644 --- a/src/quick/doc/src/appdevguide/quickstart/essentials.qdoc +++ b/src/quick/doc/src/appdevguide/quickstart/essentials.qdoc @@ -156,7 +156,7 @@ The value being displayed will vary from 0 to 150 periodically. \section1 Defining Custom QML Types for Re-use One of the most important concepts in QML is that of type re-use. An -application will probably have multiple visual elements which are all similar +application will probably have multiple visual types which are all similar (for example, multiple push buttons), and QML allows these sort of things to be defined as re-usable, custom types, to minimize code duplication and maximize readability. @@ -175,7 +175,7 @@ That type may now be re-used multiple times in the application, as follows: \endtable -In this way, modular user interface elements can be built up and re-used within +In this way, modular user interface types can be built up and re-used within an application. See \l {QML Object Attributes} diff --git a/src/quick/doc/src/appdevguide/usecases/animations.qdoc b/src/quick/doc/src/appdevguide/usecases/animations.qdoc index 3e87bae81d..b237849caf 100644 --- a/src/quick/doc/src/appdevguide/usecases/animations.qdoc +++ b/src/quick/doc/src/appdevguide/usecases/animations.qdoc @@ -31,18 +31,17 @@ QtQuick provides the ability to animate properties. Animating properties allows property values to move through intermediate values instead of immediately changing to the target value. To animate the position of an item, you can -animate the properties that controle the item's position, x and y for example, so that the item's position +animate the properties that controle the item's position, x and y for example, so that the item's position changes each frame on the way to the target position. \section1 Fluid UIs -QML was designed to facilitate the creation of fluid UIs. These are user interfaces where the UI elements animate when -they move instead of elements appearing, disappearing, or jumping. Qt Quick provides two simple ways to have UI -elements move with animation instead of instantly appearing at their new location. +QML was designed to facilitate the creation of fluid UIs. These are user interfaces where the UI components animate instead of appearing, disappearing, or jumping abruptly. Qt Quick provides two simple ways to have UI +components move with animation instead of instantly appearing at their new location. \section2 States and Transitions -QtQuick allows you to declare various UI states in \l State objects. These states are comprised of property changes from a +Qt Quick allows you to declare various UI states in \l State objects. These states are comprised of property changes from a base state, and can be a useful way of organizing your UI logic. Transitions are objects you can associate with an item to define how its properties will animate when they change due to a state change. diff --git a/src/quick/doc/src/appdevguide/usecases/layouts.qdoc b/src/quick/doc/src/appdevguide/usecases/layouts.qdoc index 2c6f4d0dd8..e8e35a93e7 100644 --- a/src/quick/doc/src/appdevguide/usecases/layouts.qdoc +++ b/src/quick/doc/src/appdevguide/usecases/layouts.qdoc @@ -27,7 +27,7 @@ /*! \page qtquick-usecase-layouts.html \title Use Case - Layouts In QML -\brief Example of how to create layouts for visual elements in a QML application +\brief Example of how to create layouts for visual components in a QML application There are several ways to position items in QML. @@ -65,7 +65,7 @@ For full details, see \l {Positioning with Anchors} and the documentation of the \section1 Positioners -For the common case of wanting to position a set of elements in a regular pattern, QtQuick provides some positioner +For the common case of wanting to position a set of types in a regular pattern, Qt Quick provides some positioner types. Items placed in a positioner are automatically positioned in some way; for example, a \l Row positions items to be horizontally adjacent (forming a row). diff --git a/src/quick/doc/src/appdevguide/usecases/styling.qdoc b/src/quick/doc/src/appdevguide/usecases/styling.qdoc index 7da230b1a0..68b8d0302c 100644 --- a/src/quick/doc/src/appdevguide/usecases/styling.qdoc +++ b/src/quick/doc/src/appdevguide/usecases/styling.qdoc @@ -27,15 +27,15 @@ /*! \page qtquick-usecase-styling.html \title Use Case - Style And Theme Support -\brief Example of how to style user interface elements in QML +\brief Example of how to style user interface components in QML -The types provided in the QtQuick module are not complete user interface elements on their own. A common use case is to -develop a set of custom styled user interface elements out of the types in the QtQuick module. This is easily +The types provided in the QtQuick module are not complete user interface components on their own. A common use case is to +develop a set of custom styled user interface components out of the types in the QtQuick module. This is easily accomplished by creating your own reusable components. With the reusable components approach, you define your own type with the appearance you want to have in your application and style that type directly. You then use that type in your application instead of the unstyled type. For -example, you could create a MyText.qml which is a Text element with certain properties set by default, and use MyText +example, you could create a MyText.qml which is a Text type with certain properties set by default, and use MyText instead of Text elsewhere in your application. \section1 Example Themed Text @@ -49,8 +49,8 @@ Because the root item in MyText.qml is a Text item it will behave as a Text item, and the properties can be overriden in specific uses. However, the properties will be set to the values specified in MyText when the item is first generated, thus applying your style by default. -For pre-styled user interface elements, see the \c{Qt Components} add-on which provides a set of components. -For accessing the system theme, see the \l{SystemPalette} element documentation. +For pre-styled user interface components, see the \c{Qt Components} add-on which provides a set of components. +For accessing the system theme, see the \l{SystemPalette} type documentation. \section1 Example Themed Button \section2 Button Definition diff --git a/src/quick/doc/src/appdevguide/usecases/userinput.qdoc b/src/quick/doc/src/appdevguide/usecases/userinput.qdoc index b31fcc4d5f..1e20f9d275 100644 --- a/src/quick/doc/src/appdevguide/usecases/userinput.qdoc +++ b/src/quick/doc/src/appdevguide/usecases/userinput.qdoc @@ -49,9 +49,9 @@ application. A \l MouseArea can be combined with either an \l Image or a \snippet qml/usecases/userinput.qml 0 For more advanced use cases requiring multiple touch points, please read the -documentation for the \l MultiPointTouchArea element and the \l PinchArea element. +documentation for the \l MultiPointTouchArea type and the \l PinchArea type. -Note that some elements have their own built in input handling. For example, +Note that some types have their own built in input handling. For example, \l Flickable responds to mouse dragging, mouse wheel scrolling, touch dragging, and touch flicking by default. @@ -59,8 +59,8 @@ and touch flicking by default. Button and key presses, from buttons on a device, a keypad, or a keyboard, can all be handled using the \l Keys attached property. This attached property -is available on all \l Item derived elements, and works with the \l Item::focus property -to determine which element receives the key event. For simple key handling, you can set the focus +is available on all \l Item derived types, and works with the \l Item::focus property +to determine which type receives the key event. For simple key handling, you can set the focus to true on a single \l Item and do all your key handling there. \snippet qml/usecases/userinput-keys.qml 0 diff --git a/src/quick/doc/src/concepts/effects/particles.qdoc b/src/quick/doc/src/concepts/effects/particles.qdoc index 08a76511b6..708e8d2740 100644 --- a/src/quick/doc/src/concepts/effects/particles.qdoc +++ b/src/quick/doc/src/concepts/effects/particles.qdoc @@ -47,26 +47,26 @@ \inqmlmodule QtQuick.Particles 2.0 \title Using the Qt Quick Particle System - Documentation for all Particle System elements can be found on the \l{QtQuick.Particles 2}{QtQuick.Particles} module page. + Documentation for all Particle System types can be found on the \l{QtQuick.Particles 2}{QtQuick.Particles} module page. - Note that to use elements from the particles module, you will need to import the types with the following line: + Note that to use types from the particles module, you will need to import the types with the following line: \code import QtQuick.Particles 2.0 \endcode \section1 The ParticleSystem - This particle system contains four main types of QML Elements: ParticleSystem, Painters, Emitters and Affectors. + This particle system contains four main types of QML types: ParticleSystem, Painters, Emitters and Affectors. - The ParticleSystem element ties all the other elements together, and manages the shared timeline. Painters, Emitters + The ParticleSystem type ties all the other types together, and manages the shared timeline. Painters, Emitters and Affectors must all have the same ParticleSystem to be able to interact with each other. You may have as many ParticleSystems as you want subject to this constraint, so the logical separation is to have - one ParticleSystem for all the elements that you want to interact, or just one if the number of elements is small + one ParticleSystem for all the types that you want to interact, or just one if the number of types is small and they are easily kept under control.. \section1 Logical Particles - All the particle system elements act on "logical particles". Every particle has a logical representation inside - the particle system, and this is what the elements act upon. Not every logical particle needs to be visualized, + All the particle system types act on "logical particles". Every particle has a logical representation inside + the particle system, and this is what the types act upon. Not every logical particle needs to be visualized, and some logical particles could lead to multiple visual particles being drawn on screen. \section1 Particle Groups @@ -76,16 +76,16 @@ can have stochastic state transitions. Groups control particles because you can never access an individual particle with any of the particle system - elements. All elements act on groups as a whole, and so any particles that need to behave differently from each + types. All types act on groups as a whole, and so any particles that need to behave differently from each other (aside from the usual stochastic parameter variation) will need to be in different groups. Particles can also change groups dynamically. When this happens the particles trajectory is unaltered, but it can be acted upon by different ParticlePainters or Affectors. Particles can either have their group changed by - an Affector, or stochastic state transitions can be defined in a ParticleGroup element. + an Affector, or stochastic state transitions can be defined in a ParticleGroup type. Generally, groups should only be defined in a ParticleGroup if they require stochastic state transitions. Otherwise, it is sufficient to have the groups be defined simply by the strings used in the particle/particles properties - of the elements. + of the types. \section1 Emitters Emitters emit logical particles into the system. These particles have a trajectory and lifespan, but no visualization. @@ -96,16 +96,16 @@ were an Emitter on it with the same properties as the TrailEmitter. \section1 ParticlePainters - Painters are the elements that visualize logical particles. For each logical particle in the groups assigned to it, - which are within its bounds (or outside, if you do not set the clip property on the element) it will be visualized + Painters are the types that visualize logical particles. For each logical particle in the groups assigned to it, + which are within its bounds (or outside, if you do not set the clip property on the type) it will be visualized in a manner dependent on the type of ParticlePainter. The base type of ParticlePainter does not draw anything. ImageParticle renders an image at the particle location. CustomParticle allows you to write your own shaders to render the particles, passing in the logical particle state as vertex data. ItemParticle allows you to visualize logical particles using arbitrary QML delegates. ModelParticle is similar, but coordinates model data amongst the delegates in a similar manner to the view classes. - As the ParticlePainter is the QML element visualizing the particles in the scene, it is its Z value which is important - when trying to place particles above or below other elements visually. + As the ParticlePainter is the QML type visualizing the particles in the scene, it is its Z value which is important + when trying to place particles above or below other types visually. \section1 Affectors Affectors are an optional component of a particle system. They can perform a variety of manipulations to the simulation, @@ -115,7 +115,7 @@ \section1 Stochastic Parameters As particle systems benefit from stochastic control of parameters across a large number of instances, several stochastic helper types are used by the particle system. If you do not wish to have any stochastic variation in these parameters, - then do not specify any variation in these elements. + then do not specify any variation in these types. \section2 Directions Directions can be specified by angle and magnitude, or by x and y components. While any direction can be specified with @@ -124,9 +124,9 @@ to an arc centered on the specified point. \section2 Shapes - The particle system contains several elements which represent shapes. These elements do not visualize shapes, and are used + The particle system contains several types which represent shapes. These types do not visualize shapes, and are used for the purpose of selecting a random point within the shape. If you want a specific point with no randomness, use a 0 width - and 0 height shape (which is the default). Otherwise you can use the shape elements provides to specify an area, so that the + and 0 height shape (which is the default). Otherwise you can use the shape types to specify an area, so that the result can use a random point selected from that area. */ diff --git a/src/quick/doc/src/concepts/effects/sprites.qdoc b/src/quick/doc/src/concepts/effects/sprites.qdoc index ac3234b24c..7ee98a533b 100644 --- a/src/quick/doc/src/concepts/effects/sprites.qdoc +++ b/src/quick/doc/src/concepts/effects/sprites.qdoc @@ -79,7 +79,7 @@ immediately. \section2 Input Format -The file formats accepted by the sprite engine is the same as the file formats accepted by other QML elements, +The file formats accepted by the sprite engine is the same as the file formats accepted by other QML types, such as \l Image. In order to animate the image however, the sprite engine requires the image file to contain all of the frames of the animation. They should be arranged in a contiguous line, which may wrap from the right edge of the file to a lower row starting from the left edge of the file (and which is placed directly below the @@ -156,24 +156,24 @@ http://www.imagemagick.org/script/montage.php \section2 QML Types Using the Sprite Engine -Sprites for the sprite engine can be defined using the \l Sprite element. This element includes the input parameters +Sprites for the sprite engine can be defined using the \l Sprite type. This type includes the input parameters as well as the length of the animation and weighted transitions to other animations. It is purely a data class, and does not render anything. -\l SpriteSequence is an element which uses a sprite engine to draw the sprites defined in it. It is a single and -self-contained sprite engine, and does not interact with other sprite engines. \l Sprite elements can be shared between -sprite engine using elements, but this is not done automatically. So if you have defined a sprite in one \l SpriteSequence -you will need to redefine it (or reference the same \l Sprite element) in the sprites property of another \l SpriteSequence +\l SpriteSequence is a type which uses a sprite engine to draw the sprites defined in it. It is a single and +self-contained sprite engine, and does not interact with other sprite engines. \l Sprite types can be shared between +sprite engine using types, but this is not done automatically. So if you have defined a sprite in one \l SpriteSequence +you will need to redefine it (or reference the same \l Sprite type) in the sprites property of another \l SpriteSequence in order to transition to that animation. -Additionally, \l ImageParticle can use \l Sprite elements to define sprites for each particle. This is again a single -sprite engine per element. This works similarly to SpriteSequence, but it also has the parametrized variability provided -by the \l ImageParticle element. +Additionally, \l ImageParticle can use \l Sprite types to define sprites for each particle. This is again a single +sprite engine per type. This works similarly to SpriteSequence, but it also has the parametrized variability provided +by the \l ImageParticle type. \section1 AnimatedSprite -For use-cases which do not need to transition between animations, consider the \l AnimatedSprite element. -This element displays sprite animations with the same input format, but only one at a time. It also provides more fine-grained +For use-cases which do not need to transition between animations, consider the \l AnimatedSprite type. +This type displays sprite animations with the same input format, but only one at a time. It also provides more fine-grained manual control, as there is no sprite engine managing the timing and transitions behind the scenes. */ diff --git a/src/quick/doc/src/concepts/input/focus.qdoc b/src/quick/doc/src/concepts/input/focus.qdoc index 7af1a26ee3..1c73c9b5ba 100644 --- a/src/quick/doc/src/concepts/input/focus.qdoc +++ b/src/quick/doc/src/concepts/input/focus.qdoc @@ -52,7 +52,7 @@ is delivered to it. Otherwise, regular Qt key handling continues. stops. Otherwise the event is "bubbled up", by recursively passing it to each Item's parent until either the event is accepted, or the root Item is reached. -If the \c {Rectangle} element in the following example has active focus and the \c A key is pressed, +If the \c {Rectangle} type in the following example has active focus and the \c A key is pressed, it will bubble up to its parent. However, pressing the \c B key will bubble up to the root item and thus subsequently be ignored. @@ -69,7 +69,7 @@ See also the \l {Keys}{Keys attached property} and \l {KeyNavigation}{KeyNavigat Whether or not an \l Item has active focus can be queried through the property \c {Item::activeFocus} property. For example, here we have a \l Text -element whose text is determined by whether or not it has active focus. +type whose text is determined by whether or not it has active focus. \snippet qml/focus/rectangle.qml active focus @@ -79,7 +79,7 @@ An \l Item requests focus by setting the \c focus property to \c true. For very simple cases simply setting the \c focus property is sometimes sufficient. If we run the following example with \l{qtquick-qmlscene.html} -{qmlscene}, we see that the \c {keyHandler} element has active focus and +{qmlscene}, we see that the \c {keyHandler} type has active focus and pressing the \c A, \c B, or \c C keys modifies the text appropriately. \snippet qml/focus/basicwidget.qml focus true @@ -107,11 +107,11 @@ the second widget receives the focus. \image declarative-qmlfocus2.png Looking at both \c MyWidget and \c window code, the problem is evident - there -are three elements that set the \c focus property set to \c true. The two +are three types that set the \c focus property set to \c true. The two MyWidget sets the \c focus to \c true and the \c window component also sets the -focus. Ultimately, only one element can have keyboard focus, and the system has -to decide which element receives the focus. When the second MyWidget is created, -it receives the focus because it is the last element to set its \c focus +focus. Ultimately, only one type can have keyboard focus, and the system has +to decide which type receives the focus. When the second MyWidget is created, +it receives the focus because it is the last type to set its \c focus property to \c true. This problem is due to visibility. The \c MyWidget component would like to have @@ -121,9 +121,9 @@ imported components are requesting the focus. To solve this problem, the QML introduces a concept known as a \e {focus scope}. For existing Qt users, a focus scope is like an automatic focus proxy. -A focus scope is created by declaring the \l FocusScope element. +A focus scope is created by declaring the \l FocusScope type. -In the next example, a \l FocusScope element is added to the component, and the +In the next example, a \l FocusScope type is added to the component, and the visual result shown. \snippet qml/focus/myfocusscopewidget.qml widget in focusscope @@ -133,23 +133,23 @@ visual result shown. Conceptually \e {focus scopes} are quite simple. \list -\li Within each focus scope one element may have \c {Item::focus} set to +\li Within each focus scope one object may have \c {Item::focus} set to \c true. If more than one \l Item has the \c focus property set, the -last element to set the \c focus will have the focus and the others are unset, +last type to set the \c focus will have the focus and the others are unset, similar to when there are no focus scopes. -\li When a focus scope receives active focus, the contained element with -\c focus set (if any) also gets the active focus. If this element is +\li When a focus scope receives active focus, the contained type with +\c focus set (if any) also gets the active focus. If this type is also a \l FocusScope, the proxying behavior continues. Both the focus scope and the sub-focused item will have \c activeFocus property set. \endlist -Note that, since the FocusScope element is not a visual element, the properties +Note that, since the FocusScope type is not a visual type, the properties of its children need to be exposed to the parent item of the FocusScope. Layouts -and positioning elements will use these visual and styling properties to create -the layout. In our example, the \c Column element cannot display the two widgets +and positioning types will use these visual and styling properties to create +the layout. In our example, the \c Column type cannot display the two widgets properly because the FocusScope lacks visual properties of its own. The MyWidget component directly binds to the \c rectangle properties to allow the \c Column -element to create the layout containing the children of the FocusScope. +type to create the layout containing the children of the FocusScope. So far, the example has the second component statically selected. It is trivial now to extend this component to make it clickable, and add it to the original @@ -167,12 +167,12 @@ The MyClickableWidget code: When a QML \l Item explicitly relinquishes focus (by setting its \c focus property to \c false while it has active focus), the -system does not automatically select another element to receive focus. That is, +system does not automatically select another type to receive focus. That is, it is possible for there to be no currently active focus. See the \l{declarative/keyinteraction/focus}{Keyboard Focus example} for a demonstration of moving keyboard focus between multiple areas using FocusScope -elements. +types. \section1 Advanced uses of Focus Scopes @@ -197,8 +197,8 @@ the current item changes, the \l ListView sets the delegate's \c {Item::focus} property. As the \l ListView is a focus scope, this doesn't affect the rest of the application. However, if the \l ListView itself has active focus this causes the delegate itself to receive active focus. -In this example, the root element of the delegate is also a focus scope, -which in turn gives active focus to the \c {Text} element that actually performs +In this example, the root type of the delegate is also a focus scope, +which in turn gives active focus to the \c {Text} type that actually performs the work of handling the \c {Return} key. All of the QML view classes, such as \l PathView and \l GridView, behave diff --git a/src/quick/doc/src/concepts/input/mouse.qdoc b/src/quick/doc/src/concepts/input/mouse.qdoc index a1fbb6ce0e..a32100f830 100644 --- a/src/quick/doc/src/concepts/input/mouse.qdoc +++ b/src/quick/doc/src/concepts/input/mouse.qdoc @@ -33,11 +33,11 @@ \tableofcontents -\section1 Mouse Elements +\section1 Mouse Types \list -\li \l{MouseArea} Element -\li \l{MouseEvent} Object +\li \l{MouseArea} type +\li \l{MouseEvent} object \endlist \section1 Mouse Event Handling @@ -49,7 +49,7 @@ accept mouse events within a defined area. \section1 Defining a Mouse Area -The \l MouseArea element receives events within a defined area. One quick way +The \l MouseArea type receives events within a defined area. One quick way to define this area is to anchor the \c MouseArea to its parent's area using the \c anchors.fill property. If the parent is a \l Rectangle (or any \l Item component), then the MouseArea will fill the area defined by the parent's @@ -59,9 +59,9 @@ definable. \section1 Receiving Events -The MouseArea element provides +The MouseArea type provides \l{qtqml-syntax-signals.html}{signals and handlers} to detect different -mouse events. The \l MouseArea element documentation describes these +mouse events. The \l MouseArea type documentation describes these gestures in greater detail: \list @@ -96,8 +96,8 @@ positioning even when there are no mouse button presses. Setting the \c exited, and \c positionChanged signal and their respective signal handlers. \snippet qml/mousearea/mousearea-snippet.qml enable handlers -Additionally, to disable the whole mouse area, set the \c MouseArea -element's \c enabled property to \c false. +Additionally, to disable the whole mouse area, set the MouseArea +\c enabled property to \c false. \section1 MouseEvent Object diff --git a/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc b/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc index 8571879f78..f31a0895fa 100644 --- a/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc +++ b/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc @@ -177,7 +177,7 @@ register the C++ model class as a QML type (either \l{qtqml-registercpptypes.html}{directly} from a C++ entry-point, or within the initialization function of a \l{qtqml-modules-cppplugins.html} {QML C++ plugin}, as shown below). This would allow the model classes to be -created directly as elements within QML: +created directly as types within QML: \table \row @@ -220,5 +220,3 @@ plugins. */ - - diff --git a/src/quick/doc/src/concepts/modelviewsdata/modelview.qdoc b/src/quick/doc/src/concepts/modelviewsdata/modelview.qdoc index 7c424dd286..fd461d9dab 100644 --- a/src/quick/doc/src/concepts/modelviewsdata/modelview.qdoc +++ b/src/quick/doc/src/concepts/modelviewsdata/modelview.qdoc @@ -50,7 +50,7 @@ accessible through the delegate. \endlist To visualize data, bind the view's \c model property to a model and the -\c delegate property to a component or an element. +\c delegate property to a component or another compatible type. \section1 Displaying Data with Views @@ -59,7 +59,7 @@ To visualize data, bind the view's \c model property to a model and the \keyword qtquick-views A set of standard views are provided in the basic set of Qt Quick - graphical elements: + graphical types: \list \li \l{ListView} - arranges items in a horizontal or vertical list @@ -67,7 +67,7 @@ To visualize data, bind the view's \c model property to a model and the \li \l{PathView} - arranges items on a path \endlist - These elements have properties and behaviors exclusive to each element. + These types have properties and behaviors exclusive to each type. Visit their respective documentation for more information. \section2 Decorating Views @@ -75,7 +75,7 @@ To visualize data, bind the view's \c model property to a model and the Views allow visual customization through \e decoration properties such as the \c header, \c footer, and \c section properties. By binding an object, usually another visual object, to these properties, the views are - decoratable. A footer may include a \l Rectangle element showcasing borders + decoratable. A footer may include a \l Rectangle type showcasing borders or a header that displays a logo on top of the list. Suppose that a specific club wants to decorate its members list with its brand @@ -86,7 +86,7 @@ To visualize data, bind the view's \c model property to a model and the The club may decorate the members list by binding visual objects to the \c header and \c footer properties. The visual object may be defined inline, in - another file, or in a \l {Component} element. + another file, or in a \l {Component} type. \snippet qml/listview-decorations.qml decorations \image listview-decorations.png @@ -114,11 +114,11 @@ To visualize data, bind the view's \c model property to a model and the \snippet qml/listview-sections.qml model \snippet qml/listview-sections.qml delegate - The ListView element has the \c section + The ListView type has the \c section \l{qtqml-syntax-objectattributes.html#Attached-properties-and-attached-signal-handlers} - {attached property} that can combine adjacent and related elements into a + {attached property} that can combine adjacent and related types into a section. The section's \c property property is for selecting which list - element property to use as sections. The \c criteria can dictate how the + type property to use as sections. The \c criteria can dictate how the section names are displayed and the \c delegate is similar to the views' \l {qml-view-delegate}{delegate} property. \snippet qml/listview-sections.qml section @@ -165,7 +165,7 @@ To visualize data, bind the view's \c model property to a model and the If there is a naming clash between the model's properties and the delegate's properties, the roles can be accessed with the qualified \e model name - instead. For example, if a \l Text element had \e type or \e age properties, + instead. For example, if a \l Text type had \e type or \e age properties, the text in the above example would display those property values instead of the \e type and \e age values from the model item. In this case, the properties could have been referenced as \c model.type and \c model.age @@ -186,7 +186,7 @@ To visualize data, bind the view's \c model property to a model and the case the \e modelData role contains the same data as the named role. QML provides several types of data models among the built-in set of QML - elements. In addition, models can be created with Qt C++ and then made + types. In addition, models can be created with Qt C++ and then made available to the \l{QQmlEngine}{QMLEngine} for use by QML components. For information about creating these models, visit the \l{qtquick-modelviewsdata-cppmodels.html}{Using C++ Models with QtQuick Views} @@ -198,7 +198,7 @@ To visualize data, bind the view's \c model property to a model and the \section2 ListModel - ListModel is a simple hierarchy of elements specified in QML. The + ListModel is a simple hierarchy of types specified in QML. The available roles are specified by the \l ListElement properties. \snippet qml/qml-data-models/listelements.qml model @@ -226,7 +226,7 @@ To visualize data, bind the view's \c model property to a model and the \section2 XmlListModel XmlListModel allows construction of a model from an XML data source. The roles - are specified via the \l XmlRole element. The element needs to be imported. + are specified via the \l XmlRole type. The type needs to be imported. \code import QtQuick.XmlListModel 2.0 @@ -260,13 +260,13 @@ To visualize data, bind the view's \c model property to a model and the \snippet qml/models/visual-model-and-view.qml visual model and view Note that in the above example there is no delegate required. - The items of the model itself provide the visual elements that + The items of the model itself provide the visual types that will be positioned by the view. \section2 Integers as Models An integer can be used as a model that contains a certain number - of elements. In this case, the model does not have any data roles. + of types. In this case, the model does not have any data roles. The following example creates a ListView with five elements: \qml @@ -291,11 +291,11 @@ To visualize data, bind the view's \c model property to a model and the \section2 Object Instances as Models An object instance can be used to specify a model with a single object - element. The properties of the object are provided as roles. + type. The properties of the object are provided as roles. The example below creates a list with one item, showing the color of the \e myText text. Note the use of the fully qualified \e model.color property to - avoid clashing with \e color property of the Text element in the delegate. + avoid clashing with \e color property of the Text type in the delegate. \qml Rectangle { diff --git a/src/quick/doc/src/concepts/positioning/layouts.qdoc b/src/quick/doc/src/concepts/positioning/layouts.qdoc index 0981bddb3d..9165c2f6df 100644 --- a/src/quick/doc/src/concepts/positioning/layouts.qdoc +++ b/src/quick/doc/src/concepts/positioning/layouts.qdoc @@ -42,7 +42,7 @@ to be arranged in a regular layout. \section1 Positioners A set of standard positioners are provided in the basic set of Qt Quick -graphical elements: +graphical types: \generatelist{related} diff --git a/src/quick/doc/src/concepts/positioning/righttoleft.qdoc b/src/quick/doc/src/concepts/positioning/righttoleft.qdoc index 44bb03f394..7052de3b49 100644 --- a/src/quick/doc/src/concepts/positioning/righttoleft.qdoc +++ b/src/quick/doc/src/concepts/positioning/righttoleft.qdoc @@ -52,7 +52,7 @@ forward buttons in music players. \section1 Text Alignment -(This applies to the \l Text, \l TextInput and \l TextEdit elements.) +(This applies to the \l Text, \l TextInput and \l TextEdit types.) When the horizontal alignment of a text item is not explicitly set, the text element is automatically aligned to the natural reading direction of the text. By default left-to-right text @@ -72,9 +72,9 @@ the effective alignment of the text element that takes the mirroring into accoun \section1 Layout direction of positioners and views -(This applies to the \l Row, \l Grid, \l Flow, \l ListView and \l GridView elements.) +(This applies to the \l Row, \l Grid, \l Flow, \l ListView and \l GridView types.) -From Qt Quick 1.1 onwards, elements used for horizontal positioning and model views have gained a \c layoutDirection +From Qt Quick 1.1 onwards, types used for horizontal positioning and model views have gained a \c layoutDirection property for controlling the horizontal direction of the layouts. Setting \c layoutDirection to \c Qt.RightToLeft causes items to be laid out from the right to left. By default Qt Quick follows the left-to-right layout direction. @@ -91,13 +91,13 @@ views that takes the mirroring into account can be read from the \c effectiveLay The attached property \l LayoutMirroring is provided as a convenience for easily implementing right-to-left support for existing left-to-right Qt Quick applications. It mirrors the behavior of \l {anchor-layout} {Item anchors}, the layout direction of \l{Composing User Interfaces with QML#Positioners}{positioners} and -\l{qtquick-modelviewsdata-modelview.html}{model views}, and the explicit text alignment of QML text elements. +\l{qtquick-modelviewsdata-modelview.html}{model views}, and the explicit text alignment of QML text types. You can enable layout mirroring for a particular \l Item: \snippet qml/righttoleft.qml 2 -Or set all child elements to also inherit the layout direction: +Or set all child types to also inherit the layout direction: \snippet qml/righttoleft.qml 3 @@ -105,12 +105,12 @@ Applying mirroring in this manner does not change the actual value of the releva \c layoutDirection or \c horizontalAlignment properties. The separate read-only property \c effectiveLayoutDirection can be used to query the effective layout direction of positioners and model views that takes the mirroring into account. Similarly the \l Text, -\l TextInput and \l TextEdit elements have gained the read-only property \c effectiveHorizontalAlignment +\l TextInput and \l TextEdit types have gained the read-only property \c effectiveHorizontalAlignment for querying the effective visual alignment of text. For anchors, the read only \l {Item::anchors.top}{anchors.mirrored} property reflects whether anchors have been mirrored. Note that application layouts and animations that are defined using \l {Item::}{x} property values (as -opposed to anchors or positioner elements) are not affected by the \l LayoutMirroring attached property. +opposed to anchors or positioner types) are not affected by the \l LayoutMirroring attached property. Therefore, adding right-to-left support to these types of layouts may require some code changes to your application, especially in views that rely on both the anchors and x coordinate-based positioning. Here is one way to use the \l LayoutMirroring attached property to apply mirroring to an item that is positioned using \l {Item::}{x} @@ -118,10 +118,10 @@ coordinates: \snippet qml/righttoleft.qml 4 -Not all layouts should necessarily be mirrored. There are cases where a visual element is positioned to +Not all layouts should necessarily be mirrored. There are cases where a visual type is positioned to the right side of the screen for improved one-handed use, because most people are right-handed, and not -because of the reading direction. In the case that a child element should not be affected by mirroring, -set the \l {LayoutMirroring::enabled}{LayoutMirroring.enabled} property for that element to false. +because of the reading direction. In the case that a child type should not be affected by mirroring, +set the \l {LayoutMirroring::enabled}{LayoutMirroring.enabled} property for that type to false. Qt Quick is designed for developing animated, fluid user interfaces. When mirroring your application, remember to test that the animations and transitions continue to work as expected. If you do not have the resources to add @@ -130,7 +130,7 @@ aligned and just make sure that text is translated and aligned properly. \section1 Mirroring icons -(This applies to \l Image, \l BorderImage and \l AnimatedImage elements.) +(This applies to \l Image, \l BorderImage and \l AnimatedImage types.) Most images do not need to be mirrored, but some directional icons, such as arrows, may need to be mirrored. The painting of these icons can be mirrored with a dedicated \c mirror property introduced in Qt Quick 1.1: diff --git a/src/quick/doc/src/concepts/positioning/topic.qdoc b/src/quick/doc/src/concepts/positioning/topic.qdoc index 799f578d6e..25fc6eaab7 100644 --- a/src/quick/doc/src/concepts/positioning/topic.qdoc +++ b/src/quick/doc/src/concepts/positioning/topic.qdoc @@ -42,11 +42,11 @@ positioning with coordinate bindings, and layouts. Items can be positioned manually. If the user-interface is going to be static, manual positioning provides the most efficient form of positioning. -In any user-interface, the visual elements exist at a particular location in +In any user-interface, the visual types exist at a particular location in the screen coordinates at any instant in time. While fluidly animated and dynamic user-interfaces are a major focus of Qt Quick, statically-positioned user interfaces are still a viable option. What's more, if the position of -those elements does not change, it can often be more performant to specify +those types does not change, it can often be more performant to specify the position manually than to use the more dynamic positioning methods documented in proceeding sections. @@ -145,7 +145,7 @@ There are many well-known layouts which work well in user-interfaces, such as grids and lists, rows and columns. Qt Quick supports these sort of pre-defined layouts, which can often be more performant to draw than anchor or binding-based layouts. See the documentation on -\l{qtquick-positioning-layouts.html}{layout elements} for more +\l{qtquick-positioning-layouts.html}{layout types} for more information about utilizing pre-defined layouts. @@ -153,8 +153,8 @@ information about utilizing pre-defined layouts. \section1 Right-To-Left Support The directionality of the written form of a language often has a great impact -on how the visual elements of a user-interface should be positioned. Qt Quick -supports right-to-left positioning of elements through the predefined-layouts +on how the visual types of a user-interface should be positioned. Qt Quick +supports right-to-left positioning of types through the predefined-layouts as well as right-to-left text layouts. Please see the documentation about @@ -163,4 +163,3 @@ Please see the documentation about */ - diff --git a/src/quick/doc/src/concepts/statesanimations/animations.qdoc b/src/quick/doc/src/concepts/statesanimations/animations.qdoc index 438804ce41..dcf1d49a72 100644 --- a/src/quick/doc/src/concepts/statesanimations/animations.qdoc +++ b/src/quick/doc/src/concepts/statesanimations/animations.qdoc @@ -31,7 +31,7 @@ \title Animation and Transitions in Qt Quick \brief the animation system in Qt Quick -\section1 Animation and Transitions Elements +\section1 Animation and Transitions Types \generatelist{related} \list \li \l {Transition} - Animates transitions during state changes @@ -45,7 +45,7 @@ \li \l {ScriptAction} - Runs scripts during an animation \endlist -Elements that animate properties based on data types +Types that animate properties based on data types \annotatedlist qtquick-animation-properties \list \li \l {PropertyAnimation} - Animates property changes @@ -57,11 +57,11 @@ Elements that animate properties based on data types \li \l {AnchorAnimation} - Animates anchor changes \endlist -Animations are created by applying animation elements to property -values. Animation elements will interpolate property values to create smooth +Animations are created by applying animation types to property +values. Animation types will interpolate property values to create smooth transitions. As well, state transitions may assign animations to state changes. -To create an animation, use an appropriate animation element for the type of +To create an animation, use an appropriate animation type for the type of the property that is to be animated, and apply the animation depending on the type of behavior that is required. @@ -79,8 +79,8 @@ animations provide timing controls and allows different interpolations through \snippet qml/animation.qml property animation -Specialized \l{qml-property-animation-elements}{property animation elements} -have more efficient implementations than the \l{PropertyAnimation} element. They +Specialized \l{qml-property-animation-types}{property animation types} +have more efficient implementations than the \l{PropertyAnimation} type. They are for setting animations to different QML types such as \c int, \c color, and rotations. Similarly, the \l{ParentAnimation} can animate parent changes. @@ -152,8 +152,8 @@ values. abrupt property changes; animations smooth transitions to produce visually appealing state changes. -The \l{Transition} element can contain -\l{qml-animation-elements}{animation elements} to interpolate property changes +The \l{Transition} type can contain +\l{qml-animation-types}{animation types} to interpolate property changes caused by state changes. To assign the transition to an object, bind it to the \c transitions property. @@ -176,8 +176,8 @@ that the transition applies to any state change. \section2 Default Animation as Behaviors Default property animations are set using \e {behavior animations}. Animations -declared in \l {Behavior} elements apply to the property and animates any -property value changes. However, Behavior elements have an +declared in \l {Behavior} types apply to the property and animates any +property value changes. However, Behavior types have an \c enabled property to purposely enable or disable the behavior animations. A ball component might have a behavior animation assigned to its \c x, \c y, and @@ -204,8 +204,8 @@ sequence or in parallel. A banner component may have several icons or slogans to display, one after the other. The \c opacity property could transform to \c 1.0 denoting an opaque -object. Using the \l{SequentialAnimation} element, the opacity animations will -play after the preceding animation finishes. The \l{ParallelAnimation} element +object. Using the \l{SequentialAnimation} type, the opacity animations will +play after the preceding animation finishes. The \l{ParallelAnimation} type will play the animations at the same time. \snippet qml/animation.qml sequential animation @@ -214,7 +214,7 @@ Once individual animations are placed into a SequentialAnimation or ParallelAnimation, they can no longer be started and stopped independently. The sequential or parallel animation must be started and stopped as a group. -The \l SequentialAnimation element is also useful for playing +The \l SequentialAnimation type is also useful for playing \l{qml-transition-animations}{transition animations} because animations are played in parallel inside transitions. @@ -227,9 +227,9 @@ demonstration of creating and combining multiple animations in QML. There are different methods to control animations. \section2 Animation Playback -All animation types inherit from the \l Animation element. It is not -possible to create \l Animation objects; instead, this element provides the -essential properties and methods for animation elements. Animation elements have +All animation types inherit from the \l Animation type. It is not +possible to create \l Animation objects; instead, this type provides the +essential properties and methods for animation types. Animation types have \c{start()}, \c{stop()}, \c{resume()}, \c{pause()}, \c {restart()}, and \c{complete()} -- all of these methods control the execution of animations. @@ -249,9 +249,9 @@ to a particular curve. For more information about the easing curves, visit the The \l{declarative/animation/easing}{easing example} visually demonstrates each of the different easing types. -\section2 Other Animation Elements +\section2 Other Animation Types -In addition, QML provides several other elements useful for animation: +In addition, QML provides several other types useful for animation: \list \li PauseAnimation: enables pauses during animations @@ -261,7 +261,7 @@ be used together with StateChangeScript to reused existing scripts without animating the property change \endlist -These are specialized animation elements that animate different property types +These are specialized animation types that animate different property types \list \li SmoothedAnimation: a specialized NumberAnimation that provides smooth changes in animation when the target value changes diff --git a/src/quick/doc/src/concepts/statesanimations/states.qdoc b/src/quick/doc/src/concepts/statesanimations/states.qdoc index 7ef05ac2ac..d9978d454e 100644 --- a/src/quick/doc/src/concepts/statesanimations/states.qdoc +++ b/src/quick/doc/src/concepts/statesanimations/states.qdoc @@ -42,10 +42,10 @@ will turn off. In the \c caution state, the yellow light is on while the other lights are turned off. In QML, \e states are a set of property configurations defined in a \l State -element. Different configurations could, for example: +type. Different configurations could, for example: \list -\li Show some UI elements and hide others +\li Show some UI components and hide others \li Present different available actions to the user \li Start, stop, or pause animations \li Execute some script required in the new state @@ -59,7 +59,7 @@ property. Each state within a component has a unique \c name, an empty string being the default. To change the current state of an item, set the \l {Item::}{state} property to the name of the state. -Non-Item objects may use states through the \l StateGroup element. +Non-Item objects may use states through the \l StateGroup type. \section1 Creating States @@ -70,21 +70,21 @@ A warning \c signal component may have two states, the \c NORMAL and the \c CRITICAL state. Suppose that in the \c NORMAL state, the \c color of the signal should be \c green and the warning \c flag is down. Meanwhile, in the \c CRITICAL state, the \c color should be \c red and the flag is \c up. We may -model the states using the \c State element and the color and flag -configurations with the \c PropertyChanges element. +model the states using the \c State type and the color and flag +configurations with the \c PropertyChanges type. \snippet qml/states.qml signal states -The \l PropertyChanges element will change the values of object properties. +The \l PropertyChanges type will change the values of object properties. Objects are referenced through their \l{qtqml-syntax-objectattributes.html#the-id-assignment}{id}. Objects outside the component are also referenced using the \c id property, exemplified by the property change to the external \c flag object. Further, the state may change by assigning the \c state property with the -appropriate signal state. A state switch could be in a \l MouseArea element, +appropriate signal state. A state switch could be in a \l MouseArea type, assigning a different state whenever the signal receives a mouse click. \snippet qml/states.qml switch states -The State element is not limited to performing modifications on property values. +The State type is not limited to performing modifications on property values. It can also: \list \li Run some script using \l StateChangeScript @@ -103,7 +103,7 @@ will load the default state. \section1 The \c when Property -For convenience, the \l State element has a \c when property that can bind to +For convenience, the \l State type has a \c when property that can bind to expressions to change the state whenever the bound expression evaluates to \c true. The \c when property will revert the state back to the \l {The Default State}{default state} when the expression evaluates to false. @@ -114,7 +114,7 @@ The \c bell component will change to the \c RINGING state whenever the \section1 Animating State Changes -State changes induce abrupt value changes. The \l Transition element allow +State changes induce abrupt value changes. The \l Transition type allow smoother changes during state changes. In transitions, animations and interpolation behaviors are definable. The \l{qtquick-statesanimations-animations.html} diff --git a/src/quick/doc/src/concepts/statesanimations/topic.qdoc b/src/quick/doc/src/concepts/statesanimations/topic.qdoc index bbcee5a7d2..cb154a0370 100644 --- a/src/quick/doc/src/concepts/statesanimations/topic.qdoc +++ b/src/quick/doc/src/concepts/statesanimations/topic.qdoc @@ -54,7 +54,7 @@ part of a selection group. Each of those states may have certain associated visual appearance (neutral, highlighted, expanded, and so forth). -Qt Quick provides a \c{State} element with properties which define its semantics +Qt Quick provides a \c{State} type with properties which define its semantics and can be used to trigger behavior or animations. See the documentation about \l{qtquick-statesanimations-states.html}{Qt Quick States} for more information. @@ -66,7 +66,7 @@ that item will change. A transition is an "edge" between two states. It may trigger other events to occur, as other parts of the application may have behavior which is triggered when a certain state is entered or left. -Qt Quick provides the \c{Transition} element which has properties which define +Qt Quick provides the \c{Transition} type which has properties which define what will occur when the application changes from one state to another. See the documentation on \l{qtquick-statesanimations-animations.html#transitions-during-state-changes} @@ -84,9 +84,9 @@ changed, it can be moved in an fluidly animated fashion so that the eye of the user can track the change. These types of animations are supported in Qt Quick through various animation -and transition elements. See the documentation on +and transition types. See the documentation on \l{qtquick-statesanimations-animations.html} -{Animations and Transitions In Qt Quick} for information about these elements +{Animations and Transitions In Qt Quick} for information about these types and how to use them. @@ -107,7 +107,7 @@ is an example of a QML object Please see the documentation about \l{qtquick-statesanimations-animations.html#default-animation-as-behaviors} {default property animations} for more information about using the \l Behavior -element to provide default property change animations. +type to provide default property change animations. It is important to note, that using default property animations (via the \l Behavior type) in combination with state-transition animations can sometimes diff --git a/src/quick/doc/src/dynamicview-tutorial.qdoc b/src/quick/doc/src/dynamicview-tutorial.qdoc index 26f418516a..9c224f8642 100644 --- a/src/quick/doc/src/dynamicview-tutorial.qdoc +++ b/src/quick/doc/src/dynamicview-tutorial.qdoc @@ -142,7 +142,7 @@ so that is above other items in the stacking order and isn't obscured as it is d \example quick/tutorials/dynamicview/dynamicview3 The next step in our application to move items within the list as they're dragged so that we -can re-order the list. To achieve this we introduce three new elements to our application; +can re-order the list. To achieve this we introduce three new types to our application; VisualDataModel, \l Drag and DropArea. \snippet quick/tutorials/dynamicview/dynamicview3/dynamicview.qml 0 @@ -169,8 +169,8 @@ to the index of the item it was dragged over. \snippet quick/tutorials/dynamicview/dynamicview3/dynamicview.qml 3 -To move the items within the view we use a VisualDataModel. The VisualDataModel element is used by -the view elements to instantiate delegate items from model data and when constructed explicitly can +To move the items within the view we use a VisualDataModel. The VisualDataModel type is used by +the view types to instantiate delegate items from model data and when constructed explicitly can be used to filter and re-order the model items provided to ListView. The \l {QtQuick2::VisualDataModel::items}{items} property of VisualDataModel provides access to the view's items and allows us to change the visible order without modifying the source model. To diff --git a/src/quick/doc/src/qtquick.qdoc b/src/quick/doc/src/qtquick.qdoc index 4326799cab..29fd33aca0 100644 --- a/src/quick/doc/src/qtquick.qdoc +++ b/src/quick/doc/src/qtquick.qdoc @@ -33,7 +33,7 @@ The Qt Quick module is the standard library for writing QML applications. While the \l{Qt QML} module provides the QML engine and language infrastructure, the Qt Quick module provides all the basic -elements necessary for creating user interfaces with QML. It +types necessary for creating user interfaces with QML. It provides a visual canvas and includes types for creating and animating visual components, receiving user input, creating data models and views and delayed object instantiation. diff --git a/src/quick/doc/src/tutorial.qdoc b/src/quick/doc/src/tutorial.qdoc index 7dbb211cb8..b1f2304529 100644 --- a/src/quick/doc/src/tutorial.qdoc +++ b/src/quick/doc/src/tutorial.qdoc @@ -79,25 +79,25 @@ types (like \l{Rectangle}, \l{Image}, ...) that come with Qt, using: \snippet quick/tutorials/helloworld/tutorial1.qml 3 -\section2 Rectangle element +\section2 Rectangle Type \snippet quick/tutorials/helloworld/tutorial1.qml 1 -We declare a root element of type \l{Rectangle}. It is one of the basic building blocks you can use to create an application in QML. +We declare a root object of type \l{Rectangle}. It is one of the basic building blocks you can use to create an application in QML. We give it an \c{id} to be able to refer to it later. In this case, we call it "page". We also set the \c width, \c height and \c color properties. -The \l{Rectangle} element contains many other properties (such as \c x and \c y), but these are left at their default values. +The \l{Rectangle} type contains many other properties (such as \c x and \c y), but these are left at their default values. -\section2 Text element +\section2 Text Type \snippet quick/tutorials/helloworld/tutorial1.qml 2 -We add a \l Text element as a child of the root Rectangle element that displays the text 'Hello world!'. +We add a \l Text type as a child of the root Rectangle type that displays the text 'Hello world!'. The \c y property is used to position the text vertically at 30 pixels from the top of its parent. -The \c anchors.horizontalCenter property refers to the horizontal center of an element. -In this case, we specify that our text element should be horizontally centered in the \e page element (see \l{anchor-layout}{Anchor-Based Layout}). +The \c anchors.horizontalCenter property refers to the horizontal center of an type. +In this case, we specify that our text type should be horizontally centered in the \e page element (see \l{anchor-layout}{Anchor-Based Layout}). The \c font.pointSize and \c font.bold properties are related to fonts and use the \l{dot properties}{dot notation}. @@ -141,8 +141,8 @@ Here is the QML code for \c Cell.qml: \snippet quick/tutorials/helloworld/Cell.qml 1 -The root element of our component is an \l Item with the \c id \e container. -An \l Item is the most basic visual element in QML and is often used as a container for other elements. +The root type of our component is an \l Item with the \c id \e container. +An \l Item is the most basic visual type in QML and is often used as a container for other types. \snippet quick/tutorials/helloworld/Cell.qml 4 @@ -160,12 +160,12 @@ We will use this signal to change the color of the text in the main QML file lat Our cell component is basically a colored rectangle with the \c id \e rectangle. -The \c anchors.fill property is a convenient way to set the size of an element. +The \c anchors.fill property is a convenient way to set the size of a visual type. In this case the rectangle will have the same size as its parent (see \l{anchor-layout}{Anchor-Based Layout}). \snippet quick/tutorials/helloworld/Cell.qml 3 -In order to change the color of the text when clicking on a cell, we create a \l MouseArea element with +In order to change the color of the text when clicking on a cell, we create a \l MouseArea type with the same size as its parent. A \l MouseArea defines a signal called \e clicked. @@ -206,7 +206,7 @@ Here is the QML code: \snippet quick/tutorials/helloworld/tutorial3.qml 2 -First, we create a new \e down state for our text element. +First, we create a new \e down state for our text type. This state will be activated when the \l MouseArea is pressed, and deactivated when it is released. The \e down state includes a set of property changes from our implicit \e {default state} @@ -225,7 +225,7 @@ Because we want the same transition to be run in reverse when changing back from we set \c reversible to \c true. This is equivalent to writing the two transitions separately. -The \l ParallelAnimation element makes sure that the two types of animations (number and color) start at the same time. +The \l ParallelAnimation type makes sure that the two types of animations (number and color) start at the same time. We could also run them one after the other by using \l SequentialAnimation instead. For more details on states and transitions, see \l {Qt Quick States} and the \l{quick/animation/states}{states and transitions example}. |