diff options
Diffstat (limited to 'src/quick/doc')
28 files changed, 193 insertions, 207 deletions
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}. |