| qquickanimation.cpp |
!
\qmltype Animation
\nativetype QQuickAbstractAnimation
\inqmlmodule QtQuick
\ingroup qtquick-transitions-animations
\brief Is the base of all QML animations.
The Animation type cannot be used directly in a QML file. It exists
to provide a set of common properties and methods, available across all the
other animation types that inherit from it. Attempting to use the Animation
type directly will result in an error.
|
97954 |
- |
| qquickanimation_p.h |
|
14140 |
- |
| qquickanimation_p_p.h |
connectedTimeLine(false), |
9937 |
- |
| qquickanimationcontroller.cpp |
!
\qmltype AnimationController
\nativetype QQuickAnimationController
\inqmlmodule QtQuick
\ingroup qtquick-animation-control
\brief Enables manual control of animations.
Normally animations are driven by an internal timer, but the AnimationController
allows the given \a animation to be driven by a \a progress value explicitly.
|
8263 |
- |
| qquickanimationcontroller_p.h |
|
1799 |
- |
| qquickanimator.cpp |
!
\qmltype Animator
\nativetype QQuickAnimator
\inqmlmodule QtQuick
\since 5.2
\ingroup qtquick-transitions-animations
\inherits Animation
\brief Is the base of all QML animators.
Animator types are a special type of animation which operate
directly on Qt Quick's scene graph, rather than the QML objects and their
properties like regular Animation types do. This has the benefit that
Animator based animations can animate on the \l
{Threaded Render Loop ('threaded')}{scene graph's rendering thread} even when the
UI thread is blocked.
The value of the QML property will be updated after the animation has
finished. The property is not updated while the animation is running.
The Animator types can be used just like any other Animation type.
\snippet qml/animators.qml mixed
If all sub-animations of ParallelAnimation and SequentialAnimation
are Animator types, the ParallelAnimation and SequentialAnimation will
also be treated as an Animator and be run on the scene graph's rendering
thread when possible.
The Animator types can be used for animations during transitions, but
they do not support the \l {Transition::reversible}{reversible}
property.
The Animator type cannot be used directly in a QML file. It exists
to provide a set of common properties and methods, available across all the
other animator types that inherit from it. Attempting to use the Animator
type directly will result in an error.
\include animatornotes.qdocinc
|
17083 |
- |
| qquickanimator_p.h |
|
5287 |
- |
| qquickanimator_p_p.h |
|
1710 |
- |
| qquickanimatorcontroller.cpp |
|
6620 |
- |
| qquickanimatorcontroller_p.h |
|
2424 |
- |
| qquickanimatorjob.cpp |
|
17676 |
- |
| qquickanimatorjob_p.h |
|
7336 |
- |
| qquickapplication.cpp |
!
\qmltype Application
\nativetype QQuickApplication
\inqmlmodule QtQuick
//! once exposed: \inherits CoreApplication?
//! TODO: \ingroup ?
\brief Provides access to global application
state properties shared by many QML components.
The Application singleton exposes a subset of QApplication's properties to
QML applications.
It also provides an aboutToQuit() signal, which is the same as
QCoreApplication::aboutToQuit().
\qml
import QtQuick
Window {
id: root
visible: true
width: 800
height: 680
title: `${Application.name} (${Application.version})`
Connections {
target: Application
function onAboutToQuit() {
console.log("Bye!")
}
}
}
\endqml
\sa SystemPalette
|
9348 |
- |
| qquickapplication_p.h |
|
2473 |
- |
| qquickattachedpropertypropagator.cpp |
!
\internal
This is a copy of the type from Controls. We need it here
so that QQuickContextMenuAttached can derive from it.
### Qt 7: remove the type in Controls and make this public: QTBUG-138546
|
18516 |
- |
| qquickattachedpropertypropagator_p.h |
|
2237 |
- |
| qquickattachedpropertypropagator_p_p.h |
|
2184 |
- |
| qquickattachedpropertypropagatortarget_p.h |
|
1581 |
- |
| qquickbehavior.cpp |
!
\internal
\brief The UntypedProxyProperty class is a property used in Behavior to handle bindable properties.
Whenever a bindable property with a Behavior gets a request for its bindable interface, we instead
return the bindable interface of the UntypedProxyProperty. This causes all reads and writes to be
intercepted to use \c m_storage instead; moreover, any installed binding will also use \c m_storage
as the property data for the binding.
The BehaviorPrivate acts as an observer, listening to changes of the proxy property. If those occur,
QQuickBehavior::write is called with the new value, which will then adjust the actual property (playing
animations if necessary).
\warning The interception mechanism works only via the metaobject system, just like it is the case with
non-binadble properties and writes. Bypassing the metaobject system can thus lead to inconsistent results;
it is however currently safe, as we do not publically expose the classes, and the code in Quick plays
nicely.
|
16004 |
- |
| qquickbehavior_p.h |
|
2230 |
- |
| qquickcolor.cpp |
!
\qmltype Color
\nativetype QQuickColor
\inqmlmodule QtQuick
\brief Holds utility functions for colors.
\since 6.12
|
6674 |
- |
| qquickcolor_p.h |
|
1676 |
- |
| qquickdeliveryagent.cpp |
! \internal
Marks \a state as hovered, by a device that is a fingertip if \a fromTouch is \c true.
fromTouch is refreshed only if the entry is not hovered right now: an entry whose
hoverId is 0 is a leftover from a hover that has already ended (it stays in
hoverItems until deliverHoverEvent() prunes it), so hovering it again belongs to
whichever device is establishing hover now. As long as the entry is hovered it keeps
the flag it got when hover began, so that a finger tapping an item that a cursor
already hovers cannot turn the cursor's hover into touch hover - which
clearTouchHover() would then take away when the contact ends.
|
153891 |
- |
| qquickdeliveryagent_p.h |
|
1649 |
- |
| qquickdeliveryagent_p_p.h |
! \internal
Extra device-specific data to be stored in QInputDevicePrivate::qqExtra.
\c deliveryTargets is a list of objects that have already been visited
during event delivery:
- QQuickPointerHandlerPrivate::deviceDeliveryTargets() returns the whole
list by reference
- QQuickPointerHandler::handlePointerEvent() appends to it
- QQuickItemPrivate::handlePointerEvent() checks it to prevent delivery to
the same handler multiple times
|
11547 |
- |
| qquickfontinfo.cpp |
!
\qmltype FontInfo
\nativetype QQuickFontInfo
\inqmlmodule QtQuick
\since 6.9
\ingroup qtquick-text-utility
\brief Provides info about how a given font query is resolved.
FontInfo provides information about the actual font which is matched for a font query by Qt's
font selection system.
It corresponds to the class QFontInfo in C++.
\code
FontInfo {
id: fontInfo
font.family: "Arial"
}
Text {
text: fontInfo.family === "Arial"
? "System has 'Arial' font"
: "System does not have 'Arial' font"
}
\endcode
\sa FontMetrics, TextMetrics
|
4498 |
- |
| qquickfontinfo_p.h |
|
2214 |
- |
| qquickfontloader.cpp |
!
\qmltype FontLoader
\nativetype QQuickFontLoader
\inqmlmodule QtQuick
\ingroup qtquick-text-utility
\brief Allows fonts to be loaded by URL.
The FontLoader type is used to load fonts by URL.
The \l status indicates when the font has been loaded, which is useful
for fonts loaded from remote sources.
For example:
\qml
import QtQuick 2.0
Column {
FontLoader { id: webFont; source: "http://www.mysite.com/myfont.ttf" }
Text { text: "Fancy font"; font: webFont.font }
}
\endqml
\sa {Qt Quick Examples - Text#Fonts}{Qt Quick Examples - Text Fonts}
|
10599 |
- |
| qquickfontloader_p.h |
|
1578 |
- |
| qquickfontmetrics.cpp |
!
\qmltype FontMetrics
\nativetype QQuickFontMetrics
\inqmlmodule QtQuick
\since 5.4
\ingroup qtquick-text-utility
\brief Provides metrics for a given font.
FontMetrics calculates the size of characters and strings for a given font.
It provides a subset of the C++ \l QFontMetricsF API, with the added
ability to change the font that is used for calculations via the \l font
property.
\code
FontMetrics {
id: fontMetrics
font.family: "Arial"
}
Rectangle {
width: fontMetrics.height * 4
height: fontMetrics.height * 2
}
\endcode
\sa QFontMetricsF, TextMetrics
|
8452 |
- |
| qquickfontmetrics_p.h |
|
3089 |
- |
| qquickforeignutils.cpp |
!
\qmltype eventPoint
\nativetype QEventPoint
\inqmlmodule QtQuick
\brief Qml equivalent for \l QEventPoint.
\sa handlerPoint
eventPoint is the Qml value type representation
of \l QEventPoint.
It has the same properties as \l QEventPoint.
The following properties are available:
\list
\li \l bool \c eventPoint.accepted \br
See also \l {QEventPoint::accepted}.
\li \l PointerDevice \c eventPoint.device \br
See also \l {QEventPoint::device}.
\li \l size \c eventPoint.ellipseDiameters \br
See also \l {QEventPoint::ellipseDiameters}.
\li \l point \c eventPoint.globalGrabPosition \br
See also \l {QEventPoint::globalGrabPosition}.
\li \l point \c eventPoint.globalLastPosition \br
See also \l {QEventPoint::globalLastPosition}.
\li \l point \c eventPoint.globalPosition \br
See also \l {QEventPoint::globalPosition}.
\li \l point \c eventPoint.globalPressPosition \br
See also \l {QEventPoint::globalPressPosition}.
\li \l bool \c eventPoint.grabPosition \br
See also \l {QEventPoint::grabPosition}.
\li \l int \c eventPoint.id \br
See also \l {QEventPoint::id}.
\li \l point \c eventPoint.lastPosition \br
See also \l {QEventPoint::lastPosition}.
\li \l ulong \c eventPoint.lastTimestamp \br
See also \l {QEventPoint::lastTimestamp}.
\li \l point \c eventPoint.position \br
See also \l {QEventPoint::position}.
\li \l point \c eventPoint.pressPosition \br
See also \l {QEventPoint::pressPosition}.
\li \l int \c eventPoint.pressTimestamp \br
See also \l {QEventPoint::pressTimestamp}.
\li \l real \c eventPoint.pressure \br
See also \l {QEventPoint::pressure}.
\li \l real \c eventPoint.rotation \br
See also \l {QEventPoint::rotation}.
\li \l point \c eventPoint.sceneGrabPosition \br
See also \l {QEventPoint::sceneGrabPosition}.
\li \l point \c eventPoint.sceneLastPosition \br
See also \l {QEventPoint::sceneLastPosition}.
\li \l point \c eventPoint.scenePosition \br
See also \l {QEventPoint::scenePosition}.
\li \l ulong \c eventPoint.pressTimestamp \br
See also \l {QEventPoint::pressTimestamp}.
\li \l point \c eventPoint.scenePressPosition \br
See also \l {QEventPoint::scenePressPosition}.
\li \l {QML Enumerations}{enumeration} \c eventPoint.state \br
See also \l {QEventPoint::state}.
\li \l real \c eventPoint.timeHeld \br
See also \l {QEventPoint::timeHeld}.
\li \l ulong \c eventPoint.timestamp \br
See also \l {QEventPoint::timestamp}.
\li \l pointingDeviceUniqueId \c eventPoint.uniqueId \br
See also \l {QEventPoint::uniqueId}.
\li \l vector2d \c eventPoint.velocity \br
See also \l {QEventPoint::velocity}.
\endlist
State supports the following values:
\value EventPoint.Unknown
Unknown state; same as Qt.TouchPointUnknownState
\value EventPoint.Stationary
The event point did not move; same as Qt.TouchPointStationary
\value EventPoint.Pressed
The touch point or button is pressed; same as Qt.TouchPointPressed
\value EventPoint.Updated
The event point was updated; same as Qt.TouchPointMoved
\value EventPoint.Released
The touch point or button was released; same as Qt.TouchPointReleased
The States type is a typedef for \l {QFlags} {QFlags<State>}. It stores an OR combination of
State values. See also \l QEventPoint::States
\snippet pointerHandlers/tapHandlerGrabChanged.qml 0
|
3893 |
- |
| qquickforeignutils_p.h |
|
3052 |
- |
| qquickframeanimation.cpp |
!
\qmltype FrameAnimation
\nativetype QQuickFrameAnimation
\inqmlmodule QtQuick
\ingroup qtquick-interceptors
\since 6.4
\brief Triggers a handler at every animation frame update.
A FrameAnimation can be used to trigger an action every time animations
have progressed and an animation frame has been rendered. See the documentation
about the \l{qtquick-visualcanvas-scenegraph.html}{Scene Graph} for in-depth
information about the threaded and basic render loops.
For general animations, prefer using \c NumberAnimation and other \c Animation
elements as those provide declarative way to describe the animations.
FrameAnimation on the other hand should be used for custom imperative animations
and in use-cases like these:
\list
\li When you need to run some code on every frame update. Or e.g. every other frame,
maybe using progressive rendering.
\li When the speed / target is changing during the animation, normal QML animations
can be too limiting.
\li When more accurate frame update time is needed, e.g. for fps counter.
\endlist
Compared to \c Timer which allows to set the \c interval time, FrameAnimation runs
always in synchronization with the animation updates. If you have used \c Timer
with a short interval for custom animations like below, please consider switching
to use FrameAnimation instead for smoother animations.
\code
// BAD
Timer {
interval: 16
repeat: true
running: true
onTriggered: {
// Animate something
}
}
// GOOD
FrameAnimation {
running: true
onTriggered: {
// Animate something
}
}
\endcode
|
12192 |
- |
| qquickframeanimation_p.h |
|
2258 |
- |
| qquickglobal.cpp |
|
10005 |
- |
| qquickimageprovider.cpp |
!
\class QQuickTextureFactory
\since 5.0
\brief The QQuickTextureFactory class provides an interface for loading custom textures from QML.
\inmodule QtQuick
The purpose of the texture factory is to provide a placeholder for a image
data that can be converted into an OpenGL texture.
Creating a texture directly is not possible as there is rarely an OpenGL context
available in the thread that is responsible for loading the image data.
|
25418 |
- |
| qquickimageprovider.h |
|
2511 |
- |
| qquickimageprovider_p.h |
|
1006 |
- |
| qquickinputmethod.cpp |
!
\qmlsingletontype InputMethod
\inqmlmodule QtQuick
\brief Provides access to \l QInputMethod for QML applications.
The InputMethod singleton allows access to application's \l QInputMethod object
and all its properties and slots. See the \l QInputMethod documentation for
further details.
\since 6.4
|
8584 |
- |
| qquickinputmethod_p.h |
|
2798 |
- |
| qquickopenglutils.cpp |
!
\namespace QQuickOpenGLUtils
\inmodule QtQuick
\since 6.0
\brief The QQuickOpenGLUtils namespace contains utilities for Qt
Quick when used with an OpenGL backend.
|
2869 |
- |
| qquickopenglutils.h |
|
510 |
- |
| qquickpath.cpp |
!
\qmltype PathElement
\nativetype QQuickPathElement
\inqmlmodule QtQuick
\ingroup qtquick-animation-paths
\brief PathElement is the base path type.
This type is the base for all path types. It cannot
be instantiated.
\sa Path, PathAttribute, PathPercent, PathLine, PathPolyline, PathQuad, PathCubic, PathArc,
PathAngleArc, PathCurve, PathSvg, PathRectangle
|
106246 |
- |
| qquickpath_p.h |
|
29967 |
- |
| qquickpath_p_p.h |
|
4103 |
- |
| qquickpathinterpolator.cpp |
!
\qmltype PathInterpolator
\nativetype QQuickPathInterpolator
\inqmlmodule QtQuick
\ingroup qtquick-animation-control
\brief Specifies how to manually animate along a path.
PathInterpolator provides \c x, \c y, and \c angle information for a particular \c progress
along a path.
In the following example, we animate a green rectangle along a bezier path.
\snippet qml/pathinterpolator.qml 0
|
3283 |
- |
| qquickpathinterpolator_p.h |
|
1727 |
- |
| qquickpixmap_p.h |
! \internal
A class that encapsulates the action of fetching a pixmap, as well as the
pixmap itself (indirectly via QQuickPixmapData::textureFactory) and the
responsibility of canceling outstanding requests. Rather than relying on
QPixmapCache which doesn't cache all the information Qt Quick needs,
QQuickPixmap implements its own cache, that correctly degrades over time.
(QQuickPixmapData::release() marks it as being not-currently-used, and
QQuickPixmapCache::shrinkCache() sweeps away the least-recently-released
instances until the remaining bytes are less than cache_limit.)
|
7695 |
- |
| qquickpixmapcache.cpp |
! \internal
The maximum currently-unused image data that can be stored for potential
later reuse, in bytes. See QQuickPixmapCache::shrinkCache()
|
78143 |
- |
| qquickpixmapcache_p.h |
! \internal
A composite key to identify a QQuickPixmapData instance in a QHash.
|
2270 |
- |
| qquickprofiler.cpp |
|
2661 |
- |
| qquickprofiler_p.h |
|
14332 |
- |
| qquickpropertychanges.cpp |
!
\qmltype PropertyChanges
\inqmlmodule QtQuick
\ingroup qtquick-states
\brief Describes new property bindings or values for a state.
PropertyChanges is used to define the property values or bindings in a
\l State. This enables an item's property values to be changed when it
\l {Qt Quick States}{changes between states}.
To create a PropertyChanges object, bind to properties of the target
item like you would bind to local properties. This way you can define
the new property values or bindings. For example:
\snippet qml/propertychanges.qml import
\codeline
\snippet qml/propertychanges.qml 0
When the mouse is pressed, the \l Rectangle changes to the \e resized
state. In this state, the PropertyChanges object sets the rectangle's
color to blue and the \c height value to that of \c container.height.
Note this automatically binds \c rect.height to \c container.height
in the \e resized state. If a property binding should not be
established, and the height should just be set to the value of
\c container.height at the time of the state change, set the \l explicit
property to \c true.
A PropertyChanges object can also override the default signal handler
for an object to implement a signal handler specific to the new state:
\qml
PropertyChanges {
myMouseArea.onClicked: doSomethingDifferent()
}
\endqml
\note PropertyChanges can be used to change anchor margins, but not other anchor
values; use AnchorChanges for this instead. Similarly, to change an \l Item's
\l {Item::}{parent} value, use ParentChange instead.
\section2 Resetting Property Values
The \c undefined value can be used to reset the property value for a state.
In the following example, when \c myText changes to the \e widerText
state, its \c width property is reset, giving the text its natural width
and displaying the whole string on a single line.
\snippet qml/propertychanges.qml reset
\section2 Immediate Property Changes in Transitions
When \l{Animation and Transitions in Qt Quick}{Transitions} are used to animate
state changes, they animate properties from their values in the current
state to those defined in the new state (as defined by PropertyChanges
objects). However, it is sometimes desirable to set a property value
\e immediately during a \l Transition, without animation; in these cases,
the PropertyAction type can be used to force an immediate property
change.
See the PropertyAction documentation for more details.
\note The \l{Item::}{visible} and \l{Item::}{enabled} properties of \l Item do not behave
exactly the same as other properties in PropertyChanges. Since these properties can be
changed implicitly through their parent's state, they should be set explicitly in all PropertyChanges.
An item will still not be enabled/visible if one of its parents is not enabled or visible.
\note For backwards compatibility with Qt 5, you can also specify PropertyChanges using
the \l target property and plain property names without IDs. For example:
\c {PropertyChanges { target: myItem; x: 15 }}. The form with ID instead of \l target
is recommended. You may also need to use the form with \l target if the file is to be
edited with \l{Qt Design Studio}. Mind that \l{Qt Design Studio} also imposes a number
of further restrictions on the files it can work with.
\sa {Qt Quick Examples - Animation#States}{States example}, {Qt Quick States}, {Qt Qml}
|
28094 |
- |
| qquickpropertychanges_p.h |
|
3134 |
- |
| qquickshortcut.cpp |
!
\qmltype Shortcut
\nativetype QQuickShortcut
\inqmlmodule QtQuick
\since 5.5
\ingroup qtquick-input
\brief Provides keyboard shortcuts.
The Shortcut type lets you handle keyboard shortcuts. The shortcut can
be set to one of the
\l{QKeySequence::StandardKey}{standard keyboard shortcuts},
or it can be described with a string containing a sequence of up to four key
presses that are needed to \l{Shortcut::activated}{activate} the shortcut.
\qml
Item {
id: view
property int currentIndex
Shortcut {
sequences: [StandardKey.NextChild]
onActivated: view.currentIndex++
}
}
\endqml
It is also possible to set multiple shortcut \l sequences, so that the shortcut
can be \l activated via several different sequences of key presses.
\sa Keys, {Keys::}{shortcutOverride()}
|
13983 |
- |
| qquickshortcut_p.h |
|
3328 |
- |
| qquicksmoothedanimation.cpp |
oldState |
17006 |
- |
| qquicksmoothedanimation_p.h |
|
2047 |
- |
| qquicksmoothedanimation_p_p.h |
|
2950 |
- |
| qquickspringanimation.cpp |
|
16851 |
- |
| qquickspringanimation_p.h |
|
2190 |
- |
| qquickstate.cpp |
!
\qmltype State
\nativetype QQuickState
\inqmlmodule QtQuick
\ingroup qtquick-states
\brief Defines configurations of objects and properties.
A \e state is a set of batched changes from the default configuration.
All items have a default state that defines the default configuration of objects
and property values. New states can be defined by adding State items to the \l {Item::states}{states} property to
allow items to switch between different configurations. These configurations
can, for example, be used to apply different sets of property values or execute
different scripts.
The following example displays a single \l Rectangle. In the default state, the rectangle
is colored black. In the "clicked" state, a PropertyChanges object changes the
rectangle's color to red. Clicking within the MouseArea toggles the rectangle's state
between the default state and the "clicked" state, thus toggling the color of the
rectangle between black and red.
\snippet qml/state.qml 0
Notice the default state is referred to using an empty string ("").
States are commonly used together with \l{Animation and Transitions in Qt Quick}{Transitions} to provide
animations when state changes occur.
\note Setting the state of an object from within another state of the same object is
not allowed.
\sa {Qt Quick Examples - Animation#States}{States example}, {Qt Quick States},
{Animation and Transitions in Qt Quick}{Transitions}, {Qt Qml}
|
20809 |
- |
| qquickstate_p.h |
|
5104 |
- |
| qquickstate_p_p.h |
|
7028 |
- |
| qquickstatechangescript.cpp |
!
\qmltype StateChangeScript
\nativetype QQuickStateChangeScript
\inqmlmodule QtQuick
\ingroup qtquick-states
\brief Specifies how to run a script in a state.
A StateChangeScript is run upon entering a state. You can optionally use
ScriptAction to specify the point in the transition at which
the StateChangeScript should be run.
\snippet qml/states/statechangescript.qml state and transition
\sa ScriptAction
|
2752 |
- |
| qquickstatechangescript_p.h |
|
1352 |
- |
| qquickstategroup.cpp |
!
\qmltype StateGroup
\nativetype QQuickStateGroup
\inqmlmodule QtQuick
\ingroup qtquick-states
\brief Provides built-in state support for non-Item types.
Item (and all derived types) provides built in support for states and transitions
via its \l{Item::state}{state}, \l{Item::states}{states} and \l{Item::transitions}{transitions} properties. StateGroup provides an easy way to
use this support in other (non-Item-derived) types.
\qml
MyCustomObject {
StateGroup {
id: myStateGroup
states: State {
name: "state1"
// ...
}
transitions: Transition {
// ...
}
}
onSomethingHappened: myStateGroup.state = "state1";
}
\endqml
\sa {Qt Quick States}{Qt Quick States}, {Animation and Transitions in Qt Quick}{Transitions}, {Qt Qml}
|
16906 |
- |
| qquickstategroup_p.h |
|
1796 |
- |
| qquickstyledtext.cpp |
QQuickStyledText supports few tags:
<b></b> - bold
<del></del> - strike out (removed content)
<s></s> - strike out (no longer accurate or no longer relevant content)
<strong></strong> - bold
<i></i> - italic
<br> - new line
<p> - paragraph
<u> - underlined text
<font color="color_name" size="1-7"></font>
<h1> to <h6> - headers
<a href="" title=""> - anchor with optional tooltip
<ol type="">, <ul type=""> and <li> - ordered and unordered lists
<pre></pre> - preformated
<img src="" title=""> - images, with optional tooltip
The opening and closing tags must be correctly nested.
|
30009 |
- |
| qquickstyledtext_p.h |
|
2117 |
- |
| qquicksystempalette.cpp |
!
\qmltype SystemPalette
\nativetype QQuickSystemPalette
\inqmlmodule QtQuick
\ingroup qtquick-visual-utility
\brief Provides access to the Qt palettes.
The SystemPalette type provides access to the Qt application
palettes. This provides information about the standard colors used
for application windows, buttons and other features. These colors
are grouped into three \e {color groups}: \c active, \c inactive,
and \c disabled. See the QPalette documentation for details about
color groups and the properties provided by SystemPalette.
This can be used to color items in a way that provides a more
native look and feel.
The following example creates a palette from the \c Active color
group and uses this to color the window and text items
appropriately:
\snippet qml/systempalette.qml 0
\sa QPalette
|
7555 |
- |
| qquicksystempalette_p.h |
|
3038 |
- |
| qquicktextmetrics.cpp |
!
\qmltype TextMetrics
\nativetype QQuickTextMetrics
\inqmlmodule QtQuick
\since 5.4
\ingroup qtquick-text-utility
\brief Provides metrics for a given font and text.
TextMetrics calculates various properties of a given string of text for a
particular font.
It provides a declarative API for the functions in \l QFontMetricsF which
take arguments.
\code
TextMetrics {
id: textMetrics
font.family: "Arial"
elide: Text.ElideMiddle
elideWidth: 100
text: "Hello World"
}
MyItem {
text: textMetrics.elidedText
}
\endcode
\sa QFontMetricsF, FontMetrics
|
6573 |
- |
| qquicktextmetrics_p.h |
|
2811 |
- |
| qquicktextselection.cpp |
!
\qmltype TextSelection
\nativetype QQuickTextSelection
\inqmlmodule QtQuick
\ingroup qtquick-visual
\ingroup qtquick-input
\brief Represents a contiguous selection of text and its properties.
\since 6.7
\l {QtQuick::TextEdit::cursorSelection}{TextEdit.cursorSelection}
represents the range of text that is currently selected (for example by
dragging the mouse). It can be used to query and modify the selected text,
as well as properties in the \l {QTextCharFormat}{character} and
\l {QTextBlockFormat}{block} formats.
Additionally, since 6.11 it's possible to create explicit non-visual instances:
\qml
TextEdit {
id: textEdit
TextSelection {
id: sel1
}
}
\endqml
\c TextEdit.cursorSelection and any explicit TextSelection instances can be
used to query and modify the specified ranges of text, as well as properties in
the \l {QTextCharFormat}{character} and \l {QTextBlockFormat}{block} formats.
\note This API is considered tech preview and may change or be removed in
future versions of Qt.
\sa TextEdit, QTextCursor
|
13414 |
- |
| qquicktextselection_p.h |
|
3734 |
- |
| qquicktimeline.cpp |
q->tick(0);
if (syncMode == QQuickTimeLine::LocalSync) {
syncAdj = -1;
} else {
syncAdj = 0;
}
|
26889 |
- |
| qquicktimeline_p_p.h |
|
4102 |
- |
| qquicktransition.cpp |
!
\qmltype Transition
\nativetype QQuickTransition
\inqmlmodule QtQuick
\ingroup qtquick-transitions-animations
\brief Defines animated transitions that occur on state changes.
A Transition defines the animations to be applied when a \l State change occurs.
For example, the following \l Rectangle has two states: the default state, and
an added "moved" state. In the "moved state, the rectangle's position changes
to (50, 50). The added Transition specifies that when the rectangle
changes between the default and the "moved" state, any changes
to the \c x and \c y properties should be animated, using an \c Easing.InOutQuad.
\snippet qml/transition.qml 0
Notice the example does not require \l{PropertyAnimation::}{to} and
\l{PropertyAnimation::}{from} values for the NumberAnimation. As a convenience,
these properties are automatically set to the values of \c x and \c y before
and after the state change; the \c from values are provided by
the current values of \c x and \c y, and the \c to values are provided by
the PropertyChanges object. If you wish, you can provide \l{PropertyAnimation::}{to} and
\l{PropertyAnimation::}{from} values anyway to override the default values.
By default, a Transition's animations are applied for any state change in the
parent item. The Transition \l {Transition::}{from} and \l {Transition::}{to}
values can be set to restrict the animations to only be applied when changing
from one particular state to another.
Top-level animations within a transition are run in parallel. To run them
sequentially, define them within a SequentialAnimation:
\snippet qml/transition-reversible.qml sequential animations
To define multiple Transitions, specify \l Item::transitions as a list:
\snippet qml/transitions-list.qml list of transitions
If multiple Transitions are specified, only a single (best-matching)
Transition will be applied for any particular state change. In the
example above, if the Rectangle enters a state other than \c "middleRight"
or \c "bottomLeft", the third Transition will be carried out, meaning the
icon will be moved to the starting point.
If a state change has a Transition that matches the same property as a
\l Behavior, the Transition animation overrides the \l Behavior for that
state change.
\sa {Animation and Transitions in Qt Quick}, {Qt Quick Examples - Animation#States}{States example}, {Qt Quick States}, {Qt Qml}
|
15766 |
- |
| qquicktransition_p.h |
|
3101 |
- |
| qquicktransitionmanager.cpp |
|
8644 |
- |
| qquicktransitionmanager_p_p.h |
|
1341 |
- |
| qquickvalidator.cpp |
!
\qmltype IntValidator
\nativetype QIntValidator
\inqmlmodule QtQuick
\ingroup qtquick-text-utility
\ingroup qtquick-text-validators
\brief Defines a validator for integer values.
The IntValidator type provides a validator for integer values.
If no \l locale is set IntValidator uses the \l {QLocale::setDefault()}{default locale} to
interpret the number and will accept locale specific digits, group separators, and positive
and negative signs. In addition, IntValidator is always guaranteed to accept a number
formatted according to the "C" locale.
The following example shows a TextInput object with an IntValidator to check
that the user has input an integer within the specified range, updating the
text color to highlight invalid input:
\snippet qml/intvalidator.qml 0
The validator will prevent the submission of text which can't possibly be
valid. However, while editing, only easily identified invalidity will be
blocked, for example sign conflicts or too many non-zero digits. This can
sometimes be surprising. The validator in the example above will for
instance allow entering "999", as values consisting of a number of digits
equal to or less than the max value are considered "intermediate" --
meaning that they are in a state where they are not valid, but could be
adjusted to be so. This is intended because the digit that prevents a
number from being in range is not necessarily the last digit typed. This
also means that an intermediate number can have leading zeros.
Adding a visual indicator based on TextInput's \l{TextInput::acceptableInput}{acceptableInput}
property can make clear to the user whether what they've typed will actually be accepted.
\sa DoubleValidator, RegularExpressionValidator, {Validating Input Text}
|
8377 |
- |
| qquickvalidator_p.h |
|
1642 |
- |
| qquickvaluetypes.cpp |
|
38309 |
- |
| qquickvaluetypes_p.h |
|
20842 |
- |