Flickable QML Type

Bietet eine Oberfläche, die „gewischt“ werden kann. Mehr...

• Liste aller Mitglieder, einschließlich geerbter Mitglieder

Eigenschaften

• acceptedButtons : flags (since 6.9)
• atXBeginning : bool
• atXEnd : bool
• atYBeginning : bool
• atYEnd : bool
• bottomMargin : real
• boundsBehavior : enumeration
• boundsMovement : enumeration
• contentHeight : real
• contentItem : Item
• contentWidth : real
• contentX : real
• contentY : real
• dragging : bool
• draggingHorizontally : bool
• draggingVertically : bool
• flickDeceleration : real
• flickableDirection : enumeration
• flicking : bool
• flickingHorizontally : bool
• flickingVertically : bool
• horizontalOvershoot : real
• horizontalVelocity : real
• interactive : bool
• leftMargin : real
• maximumFlickVelocity : real
• moving : bool
• movingHorizontally : bool
• movingVertically : bool
• originX : real
• originY : real
• pixelAligned : bool
• pressDelay : int
• rebound : Transition
• rightMargin : real
• synchronousDrag : bool
• topMargin : real
• verticalOvershoot : real
• verticalVelocity : real
• visibleArea
  • visibleArea.heightRatio : real
  • visibleArea.widthRatio : real
  • visibleArea.xPosition : real
  • visibleArea.yPosition : real

Signale

• dragEnded()
• dragStarted()
• flickEnded()
• flickStarted()
• movementEnded()
• movementStarted()

Methoden

• void cancelFlick()
• void flick(qreal xVelocity, qreal yVelocity)
• void flickTo(point position) (since 6.11)
• void flickToChild(QQuickItem *child, PositionMode mode, point offset) (since 6.11)
• void positionViewAtChild(QQuickItem *child, PositionMode mode, point offset) (since 6.11)
• void resizeContent(real width, real height, point center)
• void returnToBounds()

Ausführliche Beschreibung

Das „Flickable“-Element platziert seine untergeordneten Elemente auf einer Oberfläche, die gezogen und gewischt werden kann, wodurch die Ansicht der untergeordneten Elemente scrollt. Dieses Verhalten bildet die Grundlage für Elemente, die dazu ausgelegt sind, eine große Anzahl untergeordneter Elemente anzuzeigen, wie beispielsweise ListView und GridView.

In herkömmlichen Benutzeroberflächen lassen sich Ansichten mithilfe von Standardsteuerelementen wie Bildlaufleisten und Pfeiltasten scrollen. In manchen Situationen ist es auch möglich, die Ansicht direkt zu ziehen, indem man eine Maustaste gedrückt hält und den Cursor bewegt. In touchbasierten Benutzeroberflächen wird diese Ziehbewegung oft durch eine Wischbewegung ergänzt, bei der das Scrollen fortgesetzt wird, nachdem der Benutzer die Ansicht nicht mehr berührt.

„Flickable“ schneidet seinen Inhalt nicht automatisch ab. Wenn es nicht als Vollbildelement verwendet wird, sollten Sie in Betracht ziehen, die Eigenschaft „ clip “ auf „true“ zu setzen.

Anwendungsbeispiel

Das folgende Beispiel zeigt einen kleinen Ausschnitt eines großen Bildes, in dem der Benutzer das Bild ziehen oder wischen kann, um verschiedene Teile davon zu betrachten.

import QtQuick

Flickable {
    width: 200; height: 200
    contentWidth: image.width; contentHeight: image.height

    Image { id: image; source: "bigImage.png" }
}

Elemente, die als untergeordnete Elemente eines Flickable deklariert sind, werden automatisch dem „ contentItem “ des Flickable zugeordnet. Dies sollte berücksichtigt werden, wenn Operationen an den untergeordneten Elementen des Flickable durchgeführt werden; in der Regel sind die untergeordneten Elemente von „ contentItem “ relevant. Beispielsweise sind die Begrenzungen von Elementen, die dem Flickable hinzugefügt wurden, über contentItem.childrenRect

Beispiele für „contentX“ und „contentY“

Die folgenden Abbildungen zeigen ein „Flickable“, das in verschiedene Richtungen gewippt wird, sowie die daraus resultierenden Werte für „ contentX “ und „ contentY “. Das blaue Quadrat stellt den Inhalt des „Flickable“ dar, und der schwarze Rand stellt die Begrenzungen des „Flickable“ dar.

Einschränkungen

Dokumentation zu den Eigenschaften

acceptedButtons : flags [since 6.9]

Die Maustasten, mit denen man durch Ziehen in diesem Flickable scrollen kann.

Standardmäßig ist diese Eigenschaft auf „ Qt.LeftButton “ gesetzt, was das gleiche Verhalten wie in früheren Qt-Versionen bietet; in den meisten Benutzeroberflächen ist dieses Verhalten jedoch unerwartet. Benutzer erwarten, dass sie nur auf einem Touchscreen wischen und das Mausrad, Touchpad-Gesten oder eine Bildlaufleiste mit der Maus oder dem Touchpad verwenden. Setzen Sie den Wert auf „ Qt.NoButton “, um das Ziehen zu deaktivieren.

Sie kann auf eine „OR“-Kombination von Maustasten gesetzt werden und ignoriert dann Ereignisse von anderen Tasten.

Diese Eigenschaft wurde in Qt 6.9 eingeführt.

Diese Eigenschaften treffen zu, wenn sich die blätterbare Ansicht am Anfang bzw. am Ende befindet.

Diese Eigenschaften legen die Ränder um den Inhalt fest. Dieser Platz wird zusätzlich zu den Werten „ contentWidth “ und „ contentHeight “ reserviert.

boundsBehavior : enumeration

Diese Eigenschaft legt fest, ob die Oberfläche über die Grenzen des „Flickable“ hinausgezogen werden darf oder ob sie beim Wischen die Grenzen des „Flickable“ überschreiten darf.

Wenn der Wert „ boundsMovement “ auf „ Flickable.FollowBoundsBehavior “ gesetzt ist, vermittelt ein Wert ungleich „ Flickable.StopAtBounds “ den Eindruck, dass die Ränder der Ansicht weich sind und keine harten physischen Grenzen darstellen.

boundsBehavior kann einen der folgenden Werte annehmen:

• Flickable.StopAtBounds – Der Inhalt kann nicht über die Begrenzung des Flickable hinausgezogen werden, und Flick-Gesten schießen nicht über die Begrenzung hinaus.
• Flickable.DragOverBounds – Der Inhalt kann über die Begrenzung des Flickable hinausgezogen werden, Flick-Gesten gehen jedoch nicht über diese Begrenzung hinaus.
• Flickable.OvershootBounds – Der Inhalt kann beim Wischen über die Grenze hinausragen, darf jedoch nicht über die Grenze des Flickable hinausgezogen werden. (seit „ QtQuick 2.5 “)
• Flickable.DragAndOvershootBounds (Standard) – Der Inhalt kann über die Grenzen des Flickable hinausgezogen werden und die Grenzen beim Wischen überschreiten.

Siehe auch horizontalOvershoot, verticalOvershoot und boundsMovement.

boundsMovement : enumeration

Diese Eigenschaft gibt an, ob das „Flickable“ den Eindruck vermittelt, dass die Ränder der Ansicht weich sind und keine harte physische Begrenzung darstellen.

Der Parameter „ boundsMovement “ kann einen der folgenden Werte annehmen:

• Flickable.StopAtBounds – Dies ermöglicht die Implementierung benutzerdefinierter Randeffekte, bei denen der Inhalt nicht über die Grenzen des Flickables hinaus gezogen oder gewischt wird. Die Werte von „ horizontalOvershoot “ und „ verticalOvershoot “ können zur Implementierung benutzerdefinierter Randeffekte verwendet werden.
• Flickable.FollowBoundsBehavior (Standard) – Ob der Inhalt Zieh- oder Wischbewegungen über die Grenzen des „Flickable“ hinaus folgt, wird durch „ boundsBehavior “ bestimmt.

Das folgende Beispiel hält den Inhalt innerhalb der Grenzen und wendet stattdessen einen Flip-Effekt an, wenn über die horizontalen Grenzen hinausgewischt wird:

Flickable {
    id: flickable
    boundsMovement: Flickable.StopAtBounds
    boundsBehavior: Flickable.DragAndOvershootBounds
    transform: Rotation {
        axis { x: 0; y: 1; z: 0 }
        origin.x: flickable.width / 2
        origin.y: flickable.height / 2
        angle: Math.min(30, Math.max(-30, flickable.horizontalOvershoot))
    }
}

Das folgende Beispiel hält den Inhalt innerhalb der Begrenzungen und wendet stattdessen einen Opazitätseffekt an, wenn über die vertikalen Begrenzungen gezogen wird:

Flickable {
    boundsMovement: Flickable.StopAtBounds
    boundsBehavior: Flickable.DragOverBounds
    opacity: Math.max(0.5, 1.0 - Math.abs(verticalOvershoot) / height)
}

Siehe auch „ boundsBehavior “, „ verticalOvershoot “ und „ horizontalOvershoot “.

Die Abmessungen des Inhalts (die von Flickable gesteuerte Fläche). Diese sollten in der Regel auf die Gesamtgröße der im Flickable platzierten Elemente eingestellt werden.

Der folgende Codeausschnitt zeigt, wie diese Eigenschaften verwendet werden, um ein Bild anzuzeigen, das größer ist als das Flickable-Element selbst:

import QtQuick

Flickable {
    width: 200; height: 200
    contentWidth: image.width; contentHeight: image.height

    Image { id: image; source: "bigImage.png" }
}

In einigen Fällen können die Abmessungen des Inhalts automatisch auf der Grundlage der Eigenschaften „ childrenRect.width “ und „ childrenRect.height “ des „ contentItem “ festgelegt werden. Das vorherige Code-Schnipsel könnte beispielsweise wie folgt umgeschrieben werden:

contentWidth: contentItem.childrenRect.width; contentHeight: contentItem.childrenRect.height

Dabei wird jedoch davon ausgegangen, dass der Ursprung von `childrenRect` bei 0,0 liegt.

contentItem : Item [read-only]

Das interne Element, das die zu verschiebenden Elemente im Flickable enthält.

Elemente, die als untergeordnete Elemente eines Flickable deklariert sind, werden automatisch dem contentItem des Flickable zugeordnet.

Dynamisch erstellte Elemente müssen explizit dem „contentItem“ zugeordnet werden:

Flickable {
    id: myFlickable
    function addItem(file) {
        var component = Qt.createComponent(file)
        component.createObject(myFlickable.contentItem);
    }
}

Diese Eigenschaften enthalten die Oberflächenkoordinate, die sich derzeit in der oberen linken Ecke des Flickable befindet. Wenn Sie beispielsweise ein Bild um 100 Pixel nach oben wischen, erhöht sich der Wert von „ contentY “ um 100.

Siehe auch Examples of contentX and contentY, originX und originY.

Diese Eigenschaften geben an, ob sich die Ansicht derzeit horizontal, vertikal oder in beide Richtungen bewegt, weil der Benutzer die Ansicht zieht.

flickDeceleration : real

Diese Eigenschaft legt die Geschwindigkeit fest, mit der eine Wischbewegung abgebremst wird: Je höher der Wert, desto schneller verlangsamt sich die Bewegung, wenn der Benutzer die Wischbewegung durch Berühren beendet. Beispielsweise ist der Wert 0,0001 nahezu „reibungslos“, während sich der Wert 10000 ziemlich „klebrig“ anfühlt.

Der Standardwert ist plattformabhängig. Werte von Null oder darunter sind nicht zulässig.

flickableDirection : enumeration

Diese Eigenschaft legt fest, in welche Richtungen die Ansicht gewischt werden kann.

• Flickable.AutoFlickDirection (Standard) – ermöglicht vertikales Wischen, wenn die contentHeight nicht der Höhe des Flickable entspricht. Ermöglicht horizontales Wischen, wenn die contentWidth nicht der Breite des Flickable entspricht.
• Flickable.AutoFlickIfNeeded – Ermöglicht vertikales Wischen, wenn die contentHeight größer ist als die Höhe des Flickable. Ermöglicht horizontales Wischen, wenn die contentWidth größer ist als die Breite des Flickable. (seit QtQuick 2.7)
• Flickable.HorizontalFlick – Ermöglicht horizontales Wischen.
• Flickable.VerticalFlick – ermöglicht vertikales Wischen.
• Flickable.HorizontalAndVerticalFlick – ermöglicht das Wischen in beide Richtungen.

Diese Eigenschaften geben an, ob sich die Ansicht derzeit horizontal, vertikal oder in beide Richtungen bewegt, weil der Benutzer mit dem Finger über die Ansicht gewischt hat.

horizontalOvershoot : real [read-only]

Diese Eigenschaft gibt den horizontalen Überschwingswert an, d. h. den horizontalen Abstand, um den der Inhalt über die Grenzen des „flickable“-Elements hinausgezogen oder gewischt wurde. Der Wert ist negativ, wenn der Inhalt über den Anfang hinausgezogen oder gewischt wurde, und positiv, wenn er über das Ende hinausgezogen oder gewischt wurde; andernfalls gilt 0.0.

Ob die Werte für das Ziehen und/oder Wischen gemeldet werden, wird durch ` boundsBehavior` bestimmt. Die Überschreitungsdistanz wird auch dann gemeldet, wenn ` boundsMovement ` auf ` Flickable.StopAtBounds` gesetzt ist.

Siehe auch „ verticalOvershoot “, „ boundsBehavior “ und „ boundsMovement “.

Die momentane Bewegungsgeschwindigkeit entlang der x- und y-Achse in Pixel/Sek.

Die gemeldete Geschwindigkeit wird geglättet, um unregelmäßige Ausgabewerte zu vermeiden.

Beachten Sie, dass bei Ansichten mit großem Inhaltsumfang (mehr als das Zehnfache der Ansichtsgröße) die Wischgeschwindigkeit bei mehreren schnellen, aufeinanderfolgenden Wischbewegungen die Berührungsgeschwindigkeit überschreiten kann. Dies ermöglicht es dem Benutzer, schneller durch umfangreiche Inhalte zu blättern.

interactive : bool

Diese Eigenschaft gibt an, ob der Benutzer mit dem „Flickable“ interagieren kann. Ein Benutzer kann ein nicht interaktives „Flickable“ weder ziehen noch wischen.

Standardmäßig ist diese Eigenschaft auf „true“ gesetzt.

Diese Eigenschaft ist nützlich, um das Wischen vorübergehend zu deaktivieren. Dies ermöglicht eine spezielle Interaktion mit den untergeordneten Elementen des „Flickable“; beispielsweise möchten Sie vielleicht eine wischbare Karte einfrieren, während Sie durch ein Popup-Dialogfeld scrollen, das ein untergeordnetes Element des „Flickable“ ist.

maximumFlickVelocity : real

Diese Eigenschaft gibt die maximale Geschwindigkeit an, mit der der Benutzer die Ansicht in Pixeln pro Sekunde verschieben kann.

Der Standardwert ist plattformabhängig.

Diese Eigenschaften geben an, ob sich die Ansicht derzeit horizontal, vertikal oder in beide Richtungen bewegt, weil der Benutzer die Ansicht entweder zieht oder wischt.

Diese Eigenschaften geben den Ursprung des Inhalts an. Dieser Wert bezieht sich stets auf die Position oben links im Inhalt, unabhängig von der Layoutrichtung.

Dies ist in der Regel (0,0), jedoch können ListView und GridView aufgrund von Größenunterschieden bei Delegaten oder dem Einfügen/Entfernen von Elementen außerhalb des sichtbaren Bereichs einen beliebigen Ursprung haben.

Siehe auch contentX und contentY.

pixelAligned : bool

Diese Eigenschaft legt die Ausrichtung von „ contentX “ und „ contentY “ auf Pixel (true) oder Subpixel (false) fest.

Aktivieren Sie „pixelAligned“, um statische Inhalte oder bewegte Inhalte mit kontrastreichen Kanten zu optimieren, wie z. B. ein Pixel breite Linien, Text oder Vektorgrafiken. Deaktivieren Sie „pixelAligned“, wenn Sie die Animationsqualität optimieren möchten.

Die Standardeinstellung ist „ false “.

pressDelay : int

Diese Eigenschaft legt die Verzögerungszeit (in ms) fest, mit der ein Druckereignis an die untergeordneten Elemente des „Flickable“ weitergeleitet wird. Dies kann nützlich sein, wenn eine Reaktion auf ein Druckereignis vor einer Wischgeste unerwünschte Auswirkungen hat.

Wird das „Flickable“ vor Ablauf der Verzögerungszeit gezogen oder gewischt, wird das Druckereignis nicht ausgelöst. Wird die Schaltfläche innerhalb der Verzögerungszeit losgelassen, werden sowohl das Druck- als auch das Loslassereignis ausgelöst.

Beachten Sie, dass bei verschachtelten „Flickables“, bei denen „pressDelay“ festgelegt ist, die „pressDelay“-Einstellung der äußeren „Flickables“ durch das innerste „Flickable“ überschrieben wird. Wenn das Ziehen den Drag-Schwellenwert der Plattform überschreitet, wird das Druckereignis unabhängig von dieser Eigenschaft ausgelöst.

Siehe auch QStyleHints.

rebound : Transition

Hier wird der Übergang gespeichert, der auf die Inhaltsansicht angewendet werden soll, wenn diese wieder an die Begrenzungen des Flickable-Bereichs zurück springt. Der Übergang wird ausgelöst, wenn die Ansicht über den Rand des Inhaltsbereichs hinaus gewischt oder gezogen wird oder wenn ` returnToBounds()` aufgerufen wird.

import QtQuick 2.0

Flickable {
    width: 150; height: 150
    contentWidth: 300; contentHeight: 300

    rebound: Transition {
        NumberAnimation {
            properties: "x,y"
            duration: 1000
            easing.type: Easing.OutBounce
        }
    }

    Rectangle {
        width: 300; height: 300
        gradient: Gradient {
            GradientStop { position: 0.0; color: "lightsteelblue" }
            GradientStop { position: 1.0; color: "blue" }
        }
    }
}

Wird die oben genannte Ansicht über ihre Grenzen hinaus gewischt, kehrt sie unter Verwendung des angegebenen Übergangs in ihre Grenzen zurück:

Ist diese Eigenschaft nicht festgelegt, wird eine Standardanimation angewendet.

synchronousDrag : bool

Wenn diese Eigenschaft auf „true“ gesetzt ist, springt der Inhalt, sobald sich die Maus oder der Berührungspunkt so weit bewegt, dass das Ziehen des Inhalts beginnt, sodass das Bildpunkt des Inhalts, das sich beim Drücken unter dem Cursor oder Berührungspunkt befand, unter diesem Punkt verbleibt.

Die Standardeinstellung ist „ false “, was ein flüssigeres Erlebnis (kein Sprung) bietet, allerdings auf Kosten eines Teils der Ziehdistanz, der zu Beginn „verloren“ geht.

verticalOvershoot : real [read-only]

Diese Eigenschaft gibt den vertikalen Überschwingswert an, d. h. den vertikalen Abstand, um den der Inhalt über die Grenzen des „flickable“-Elements hinausgezogen oder gewischt wurde. Der Wert ist negativ, wenn der Inhalt über den Anfang hinausgezogen oder gewischt wurde, und positiv, wenn er über das Ende hinausgezogen oder gewischt wurde; andernfalls gilt 0.0.

Ob die Werte für das Ziehen und/oder Wischen gemeldet werden, wird durch ` boundsBehavior` bestimmt. Die Überschreitungsdistanz wird auch dann gemeldet, wenn ` boundsMovement ` auf ` Flickable.StopAtBounds` gesetzt ist.

Siehe auch „ horizontalOvershoot “, „ boundsBehavior “ und „ boundsMovement “.

visibleArea group

Diese Eigenschaften beschreiben die Position und Größe des aktuell angezeigten Bereichs. Die Größe wird als Prozentsatz der derzeit sichtbaren Gesamtansicht definiert, skaliert auf den Bereich von 0,0 bis 1,0. Die Seitenposition liegt normalerweise im Bereich von 0,0 (Anfang) bis 1,0 minus Größenverhältnis (Ende), d. h. „ yPosition “ liegt im Bereich von 0,0 bis 1,0 –heightRatio. Es ist jedoch möglich, dass der Inhalt außerhalb des normalen Bereichs gezogen wird, was dazu führt, dass auch die Seitenpositionen außerhalb des normalen Bereichs liegen.

Diese Eigenschaften werden typischerweise zum Zeichnen einer Bildlaufleiste verwendet. Zum Beispiel:

Rectangle {
    width: 200; height: 200

    Flickable {
        id: flickable
        ...
    }

    Rectangle {
        id: scrollbar
        anchors.right: flickable.right
        y: flickable.visibleArea.yPosition * flickable.height
        width: 10
        height: flickable.visibleArea.heightRatio * flickable.height
        color: "black"
    }
}

Signal-Dokumentation

dragEnded()

Dieses Signal wird ausgelöst, wenn der Benutzer das Ziehen der Ansicht beendet.

Wenn die Geschwindigkeit des Ziehvorgangs zum Zeitpunkt des Loslassens der Berührung bzw. der Maustaste ausreichend ist, wird ein Flick-Vorgang ausgelöst.

dragStarted()

Dieses Signal wird ausgelöst, wenn die Ansicht aufgrund einer Benutzeraktion gezogen wird.

flickEnded()

Dieses Signal wird ausgelöst, wenn die Ansicht nach einem Wisch oder einer Reihe von Wischgesten nicht mehr weiterläuft.

flickStarted()

Dieses Signal wird ausgelöst, wenn die Ansicht gewischt wird. Ein Wisch beginnt an der Stelle, an der die Maus oder der Finger losgelassen wird, während die Bewegung noch andauert.

movementEnded()

Dieses Signal wird ausgelöst, wenn die Ansicht aufgrund einer Benutzeraktion oder eines aufgerufenen flick() ihre Bewegung beendet. War ein Flick aktiv, wird dieses Signal ausgelöst, sobald der Flick beendet wird. War kein Flick aktiv, wird dieses Signal ausgelöst, wenn der Benutzer das Ziehen beendet – d. h. wenn die Maus losgelassen oder der Finger vom Touchscreen genommen wird.

movementStarted()

Dieses Signal wird ausgelöst, wenn sich die Ansicht aufgrund einer Benutzerinteraktion oder eines aufgerufenen flick() zu bewegen beginnt.

Methodendokumentation

void cancelFlick()

Bricht die aktuelle Flick-Animation ab.

void flick(qreal xVelocity, qreal yVelocity)

Bewegt den Inhalt mit xVelocity horizontal und yVelocity vertikal in Pixel/Sekunde.

Der Aufruf dieser Methode aktualisiert die entsprechenden Eigenschaften und Signale für Bewegung und Wischen, genau wie bei einem echten Touchscreen-Wischvorgang.

[since 6.11] void flickTo(point position)

Blättert das blätterbare Element zu „ position “.

Wenn das Wischen des „flickable“-Objekts dazu führen würde, dass am Anfang oder am Ende des „flickable“-Objekts Leerräume angezeigt würden, wird das Wischen an der Grenze gestoppt.

Diese Methode wurde in Qt 6.11 eingeführt.

[since 6.11] void flickToChild(QQuickItem *child, PositionMode mode, point offset)

Bewegt das bewegbare Element so, dass das Element „ child “ (sofern es ein untergeordnetes Element ist) an der durch „ mode “ angegebenen Position liegt. „ mode “ kann eine ODER-Kombination aus folgenden Elementen sein:

Wenn keine vertikale Ausrichtung angegeben ist, wird vertikales Wischen ignoriert. Das Gleiche gilt für die horizontale Ausrichtung.

Optional können Sie „ offset “ angeben, um eine zusätzliche Anzahl von Pixeln über die Zielausrichtung hinaus zu wischen.

Wenn das Flicken des „flickable“ am untergeordneten Element dazu führen würde, dass am Anfang oder Ende des „flickable“ Leerraum angezeigt wird, wird das Flicken am Rand beendet.

import QtQuick
import QtQuick.Controls
import QtQuick.Window

Flickable {
    id: flickable

    width: 200
    height: 200
    contentWidth: width
    contentHeight: column.height

    // Will flick to the beginning of the activeFocusItem every time it changes
    property Item activeFocusItem: Window.activeFocusItem
    onActiveFocusItemChanged: flickable.flickToChild(activeFocusItem, Flickable.AlignTop)

    Column {
        id: column

        spacing: 10

        Repeater {
            model: 10
            TextArea {}
        }
    }
}

Diese Methode wurde in Qt 6.11 eingeführt.

[since 6.11] void positionViewAtChild(QQuickItem *child, PositionMode mode, point offset)

Positionen contentX und contentY, sodass das Element child (sofern es ein untergeordnetes Element ist) an der durch mode angegebenen Position liegt. mode kann eine mit „oder“ verknüpfte Kombination der folgenden Elemente sein:

Wenn keine vertikale Ausrichtung angegeben ist, wird die vertikale Positionierung ignoriert. Dasselbe gilt für die horizontale Ausrichtung.

Optional können Sie „ offset “ angeben, um „contentX“ und „contentY“ um eine zusätzliche Anzahl von Pixeln über die Zielausrichtung hinaus zu verschieben.

Wenn die Positionierung des „flickable“ am untergeordneten Element dazu führen würde, dass am Anfang oder Ende des „flickable“ Leerräume angezeigt werden, wird das „flickable“ an der Grenze positioniert.

import QtQuick
import QtQuick.Controls
import QtQuick.Window

Flickable {
    id: flickable

    width: 200
    height: 200
    contentWidth: width
    contentHeight: column.height

    // Will center activeFocusItem in the Flickable every time it changes
    property Item activeFocusItem: Window.activeFocusItem
    onActiveFocusItemChanged: flickable.positionViewAtChild(activeFocusItem, Flickable.AlignCenter)

    Column {
        id: column

        spacing: 10

        Repeater {
            model: 10
            TextArea {}
        }
    }
}

Diese Methode wurde in Qt 6.11 eingeführt.

void resizeContent(real width, real height, point center)

Passen Sie die Größe des Inhalts auf width x height an, etwa center.

Dadurch wird der Inhalt des Flickable nicht skaliert – es werden lediglich die Abmessungen von contentWidth und contentHeight angepasst.

Eine Größenänderung des Inhalts kann dazu führen, dass dieser außerhalb der Grenzen des „Flickable“ positioniert wird. Durch den Aufruf von ` returnToBounds()` wird der Inhalt wieder innerhalb der zulässigen Grenzen verschoben.

void returnToBounds()

Stellt sicher, dass der Inhalt den gesetzlichen Vorgaben entspricht.

Diese Funktion kann aufgerufen werden, um sicherzustellen, dass der Inhalt nach der manuellen Positionierung den gesetzlichen Vorgaben entspricht.