Flickable QML Type

Bietet eine Oberfläche, die "geschnippt" 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()

Detaillierte Beschreibung

Das Element "Flickable" platziert seine untergeordneten Elemente auf einer Oberfläche, die durch Ziehen und Streichen bewegt werden kann, wodurch die Ansicht der untergeordneten Elemente gescrollt wird. Dieses Verhalten bildet die Grundlage für Elemente, die für die Anzeige einer großen Anzahl von untergeordneten Elementen konzipiert sind, wie ListView und GridView.

In herkömmlichen Benutzeroberflächen können Ansichten mit Standardsteuerelementen wie Bildlaufleisten und Pfeiltasten gescrollt werden. In manchen Situationen ist es auch möglich, die Ansicht direkt zu ziehen, indem man eine Maustaste gedrückt hält, während man den Cursor bewegt. In berührungsgesteuerten Benutzeroberflächen wird dieser Ziehvorgang häufig durch einen Flickvorgang ergänzt, bei dem der Bildlauf fortgesetzt wird, nachdem der Benutzer die Ansicht nicht mehr berührt hat.

Flickable schneidet seinen Inhalt nicht automatisch ab. Wenn es nicht als bildschirmfüllendes Element verwendet wird, sollten Sie erwägen, die Eigenschaft clip auf true zu setzen.

Beispielverwendung

Das folgende Beispiel zeigt eine kleine Ansicht auf einem großen Bild, in der der Benutzer das Bild ziehen oder streichen kann, um verschiedene Teile des Bildes zu sehen.

import QtQuick

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

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

Elemente, die als Kinder eines Flickable deklariert sind, werden automatisch dem contentItem des Flickable untergeordnet. Dies sollte berücksichtigt werden, wenn man mit den Kindern des Flickable arbeitet; normalerweise sind die Kinder von contentItem relevant. Zum Beispiel wird die Bindung von Elementen, die dem Flickable hinzugefügt wurden, verfügbar sein durch contentItem.childrenRect

Beispiele für contentX und contentY

Die folgenden Bilder zeigen, wie ein Flickable in verschiedene Richtungen geschoben wird und welche Werte sich daraus ergeben contentX und contentY. Das blaue Quadrat stellt den Inhalt des Flickable dar, und der schwarze Rand stellt die Grenzen des Flickable dar.

Beschränkungen

Dokumentation der Eigenschaft

acceptedButtons : flags [since 6.9]

Die Maustasten, die verwendet werden können, um dieses Flickable durch Ziehen zu verschieben.

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

Sie kann auf eine ODER-Kombination von Maustasten gesetzt werden und ignoriert Ereignisse von anderen Tasten.

Diese Eigenschaft wurde in Qt 6.9 eingeführt.

Diese Eigenschaften sind wahr, wenn die flickbare Ansicht am Anfang bzw. am Ende positioniert ist.

Diese Eigenschaften enthalten die Ränder um den Inhalt. Dieser Platz wird zusätzlich zu contentWidth und contentHeight reserviert.

boundsBehavior : enumeration

Diese Eigenschaft legt fest, ob die Oberfläche über die Grenzen des Flickable hinaus gezogen werden kann oder ob sie die Grenzen des Flickable überschreitet, wenn sie angeklickt wird.

Wenn boundsMovement Flickable.FollowBoundsBehavior ist, vermittelt ein anderer Wert als Flickable.StopAtBounds das Gefühl, dass die Ränder der Ansicht weich sind, anstatt eine harte physische Grenze zu bilden.

Der Wert boundsBehavior kann einer der folgenden sein:

• Flickable.StopAtBounds - der Inhalt kann nicht über die Grenze des Flickable hinaus gezogen werden, und Flicks werden nicht über den Rand hinausgehen.
• Flickable.DragOverBounds - der Inhalt kann über die Begrenzung des Flickable gezogen werden, aber die Flicks werden nicht über den Rand hinausgehen.
• Flickable.OvershootBounds - der Inhalt kann über die Begrenzung gezogen werden, aber der Inhalt kann nicht über die Begrenzung des Flickable gezogen werden. (seit QtQuick 2.5)
• Flickable.DragAndOvershootBounds (Standard) - der Inhalt kann über die Begrenzung des Flickable hinaus gezogen werden und kann die Begrenzung überschreiten, wenn er angeklickt wird.

Siehe auch horizontalOvershoot, verticalOvershoot, und boundsMovement.

boundsMovement : enumeration

Diese Eigenschaft legt fest, ob das Flickable den Eindruck erweckt, dass die Ränder der Ansicht weich sind und nicht eine harte physische Grenze darstellen.

Die boundsMovement kann eine der folgenden sein:

• Flickable.StopAtBounds - dies ermöglicht die Implementierung von benutzerdefinierten Randeffekten, bei denen der Inhalt nicht dem Ziehen oder Bewegen über die Grenzen des Flickable hinaus folgt. Die Werte von horizontalOvershoot und verticalOvershoot können verwendet werden, um benutzerdefinierte Randeffekte zu implementieren.
• Flickable.FollowBoundsBehavior (Standard) - ob der Inhalt dem Ziehen oder Flackern über die Grenzen des Flickable hinaus folgt, wird durch boundsBehavior bestimmt.

Im folgenden Beispiel bleibt der Inhalt innerhalb der Begrenzungen und wendet stattdessen einen Spiegeleffekt an, wenn er über horizontale Begrenzungen hinaus geschoben 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))
    }
}

Im folgenden Beispiel bleibt der Inhalt innerhalb der Begrenzungen und wendet stattdessen einen Deckkraft-Effekt an, wenn er über vertikale 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 kontrollierte Oberfläche). Dies sollte normalerweise auf die kombinierte Größe der im Flickable platzierten Elemente eingestellt werden.

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

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 Snippet könnte beispielsweise wie folgt umgeschrieben werden:

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

Dabei wird jedoch davon ausgegangen, dass der Ursprung des childrenRect 0,0 ist.

contentItem : Item [read-only]

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

Elemente, die als Kinder eines Flickable deklariert sind, werden automatisch dem contentItem des Flickable untergeordnet.

Dynamisch erstellte Elemente müssen explizit dem contentItem übergeordnet werden:

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

Diese Eigenschaften enthalten die aktuelle Oberflächenkoordinate in der linken oberen Ecke des Flickable. Wenn Sie zum Beispiel ein Bild um 100 Pixel nach oben bewegen, erhöht sich contentY um 100.

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

Diese Eigenschaften beschreiben, ob sich die Ansicht gerade horizontal, vertikal oder in eine der beiden Richtungen bewegt, wenn der Benutzer die Ansicht verschiebt.

flickDeceleration : real

Diese Eigenschaft gibt die Geschwindigkeit an, mit der ein Schnippen verlangsamt wird: je höher die Zahl, desto schneller verlangsamt es sich, wenn der Benutzer das Schnippen durch Berührung beendet. Zum Beispiel ist 0,0001 fast "reibungslos", und 10000 fühlt sich ziemlich "klebrig".

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

flickableDirection : enumeration

Diese Eigenschaft bestimmt, in welche Richtungen die Ansicht bewegt werden kann.

• Flickable.AutoFlickDirection (Standard) - erlaubt vertikales Kippen, wenn contentHeight nicht gleich der Höhe des Flickable ist. Erlaubt horizontales Flicking, wenn die contentWidth nicht der Breite des Flickable entspricht.
• Flickable.AutoFlickIfNeeded - erlaubt das vertikale Flackern, wenn die contentHeight größer als die Höhe des Flickable ist. AutoFlickIfNeeded - erlaubt horizontales Flackern, wenn die contentWidth größer als die Breite des Flickable ist. (seit QtQuick 2.7)
• Flickable.HorizontalFlick - ermöglicht horizontales Flackern.
• Flickable.VerticalFlick - erlaubt vertikales Flackern.
• Flickable.HorizontalAndVerticalFlick - erlaubt das Flackern in beide Richtungen.

Diese Eigenschaften beschreiben, ob sich die Ansicht gerade horizontal, vertikal oder in eine der beiden Richtungen bewegt, wenn der Benutzer die Ansicht verschiebt.

horizontalOvershoot : real [read-only]

Diese Eigenschaft enthält die horizontale Überschreitung, d. h. den horizontalen Abstand, um den der Inhalt über die Grenzen des Flickable hinaus gezogen oder geschnippt wurde. Der Wert ist negativ, wenn der Inhalt über den Anfang hinaus gezogen oder geschnippt wurde, und positiv, wenn er über das Ende hinaus geschoben wurde; ansonsten ist er 0.0.

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

Siehe auch verticalOvershoot, boundsBehavior, und boundsMovement.

Die momentane Geschwindigkeit der Bewegung entlang der x- und y-Achse, in Pixel/Sek.

Die gemeldete Geschwindigkeit wird geglättet, um eine fehlerhafte Ausgabe zu vermeiden.

Beachten Sie, dass bei Ansichten mit großem Inhalt (mehr als das 10-fache der Ansichtsgröße) die Geschwindigkeit des Streichens die Geschwindigkeit der Berührung übersteigen kann, wenn mehrere schnelle, aufeinander folgende Streichbewegungen ausgeführt werden. Dadurch kann der Benutzer schneller durch große Inhalte blättern.

interactive : bool

Diese Eigenschaft beschreibt, ob der Benutzer mit dem Flickable interagieren kann. Ein Benutzer kann ein Flickable, das nicht interaktiv ist, nicht ziehen oder streichen.

Standardmäßig ist diese Eigenschaft true.

Diese Eigenschaft ist nützlich, um das Flickern vorübergehend zu deaktivieren. Dies ermöglicht eine spezielle Interaktion mit den untergeordneten Elementen von Flickable; zum Beispiel könnten Sie eine flickbare Karte einfrieren wollen, während Sie durch einen Popup-Dialog blättern, der ein untergeordnetes Element von Flickable ist.

maximumFlickVelocity : real

Diese Eigenschaft enthält die maximale Geschwindigkeit, mit der der Benutzer die Ansicht in Pixel/Sekunde bewegen kann.

Der Standardwert ist plattformabhängig.

Diese Eigenschaften beschreiben, ob sich die Ansicht gerade horizontal, vertikal oder in eine der beiden Richtungen bewegt, da der Benutzer die Ansicht entweder zieht oder anklickt.

Diese Eigenschaften enthalten den Ursprung des Inhalts. Dieser Wert bezieht sich immer auf die linke obere Position des Inhalts, unabhängig von der Layoutrichtung.

Normalerweise ist dies (0,0), jedoch können ListView und GridView einen beliebigen Ursprung haben, der durch Variationen der Delegatengröße oder durch das Einfügen/Entfernen von Elementen außerhalb des sichtbaren Bereichs entsteht.

Siehe auch contentX und contentY.

pixelAligned : bool

Diese Eigenschaft setzt die Ausrichtung von contentX und contentY auf Pixel (true) oder Subpixel (false).

Aktivieren Sie pixelAligned, um unbewegte Inhalte oder bewegte Inhalte mit hohen Kontrastkanten zu optimieren, z. B. ein Pixel breite Linien, Text oder Vektorgrafiken. Deaktivieren Sie pixelAligned, wenn Sie die Qualität von Animationen optimieren wollen.

Die Standardeinstellung ist false.

pressDelay : int

Diese Eigenschaft gibt die Verzögerungszeit (ms) an, mit der die Kinder des Flickable auf einen Druck reagieren sollen. Dies kann nützlich sein, wenn das Reagieren auf einen Druck vor einer Flick-Aktion unerwünschte Auswirkungen hat.

Wenn das Flickable gezogen/geklickt wird, bevor die Verzögerung abläuft, wird das Druckereignis nicht ausgelöst. Wird die Schaltfläche innerhalb der Zeitüberschreitung losgelassen, werden sowohl das Drücken als auch das Loslassen ausgelöst.

Beachten Sie, dass bei verschachtelten Flickables mit eingestellter pressDelay die pressDelay der äußeren Flickables durch das innerste Flickable überschrieben wird. Wenn das Ziehen den Schwellenwert für das Ziehen der Plattform überschreitet, wird das Druckereignis unabhängig von dieser Eigenschaft ausgelöst.

Siehe auch QStyleHints.

rebound : Transition

Hier wird der Übergang festgelegt, der auf die Inhaltsansicht angewendet werden soll, wenn sie wieder an den Grenzen des Flickable einrastet. Der Übergang wird ausgelöst, wenn die Ansicht über den Rand des Inhaltsbereichs hinaus geschoben 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" }
        }
    }
}

Wenn die obige Ansicht über ihre Grenzen hinaus geschoben wird, kehrt sie unter Verwendung des angegebenen Übergangs zu ihren Grenzen zurück:

Wenn diese Eigenschaft nicht festgelegt ist, wird eine Standardanimation angewendet.

synchronousDrag : bool

Wenn diese Eigenschaft auf "true" gesetzt ist, springt der Inhalt, wenn die Maus oder der Berührungspunkt weit genug bewegt wird, um mit dem Ziehen des Inhalts zu beginnen, so dass das Inhaltspixel, das sich beim Drücken unter dem Cursor oder Berührungspunkt befand, unter diesem Punkt bleibt.

Die Standardeinstellung ist false, die eine sanftere Erfahrung (kein Sprung) auf Kosten eines Teils der Ziehdistanz am Anfang "verloren" geht.

verticalOvershoot : real [read-only]

Diese Eigenschaft enthält die vertikale Überschreitung, d. h. den vertikalen Abstand, um den der Inhalt über die Grenzen des Flickable hinaus gezogen oder geschnippt wurde. Der Wert ist negativ, wenn der Inhalt über den Anfang hinaus gezogen oder geschnippt wurde, und positiv, wenn er über das Ende hinaus geschoben wurde; ansonsten ist er 0.0.

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

Siehe auch horizontalOvershoot, boundsBehavior, und boundsMovement.

visibleArea group

Diese Eigenschaften beschreiben die Position und Größe des aktuell angezeigten Bereichs. Die Größe ist definiert als der Prozentsatz der aktuell sichtbaren Gesamtansicht, skaliert auf 0,0 - 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 in der Regel verwendet, um eine Bildlaufleiste zu zeichnen. Ein 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 ausgesendet, wenn der Benutzer aufhört, die Ansicht zu ziehen.

Wenn die Geschwindigkeit des Ziehens zum Zeitpunkt des Loslassens der Touch-/Maustaste ausreichend ist, wird ein Flick ausgelöst.

dragStarted()

Dieses Signal wird ausgegeben, wenn die Ansicht aufgrund einer Benutzerinteraktion gezogen wird.

flickEnded()

Dieses Signal wird ausgegeben, wenn sich die Ansicht nach einem Flick oder einer Reihe von Flicks nicht mehr bewegt.

flickStarted()

Dieses Signal wird ausgesendet, wenn die Ansicht geschnipst wird. Das Streichen beginnt mit dem Loslassen der Maus oder der Berührung, während sie noch in Bewegung sind.

movementEnded()

Dieses Signal wird ausgegeben, wenn die Bewegung der Ansicht aufgrund von Benutzerinteraktion oder einer generierten flick() stoppt. Wenn ein Flick aktiv war, wird dieses Signal ausgegeben, sobald der Flick aufhört. Wenn kein Flick aktiv war, wird dieses Signal ausgegeben, wenn der Benutzer aufhört zu ziehen, d.h. wenn die Maus oder der Touch losgelassen wird.

movementStarted()

Dieses Signal wird ausgegeben, wenn sich die Ansicht aufgrund von Benutzerinteraktion oder eines generierten flick() zu bewegen beginnt.

Dokumentation der Methode

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/Sek.

Durch den Aufruf dieser Methode werden die entsprechenden Bewegungs- und Streicheigenschaften und -signale aktualisiert, genau wie bei einem echten Touchscreen-Streicheln.

[since 6.11] void flickTo(point position)

Verschiebt das Flickable auf position.

Wenn das Flackern des Flickers dazu führen würde, dass am Anfang oder Ende des Flickers ein leerer Raum angezeigt wird, hört der Flicker an der Grenze auf zu flackern.

Diese Methode wurde in Qt 6.11 eingeführt.

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

Bewegt das Flickable so, dass sich das Element child (wenn es ein untergeordnetes Element ist) an der durch mode angegebenen Position befindet. mode kann eine oder eine der folgenden Kombinationen sein:

Wenn keine vertikale Ausrichtung angegeben ist, wird das vertikale Verschieben 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 verschieben.

Wenn das Flackern des Flickers am untergeordneten Element dazu führen würde, dass am Anfang oder Ende des Flickers ein leerer Raum angezeigt wird, hört der Flicker an der Begrenzung auf zu flackern.

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)

Die Positionen contentX und contentY sind so gewählt, dass sich das Element child (falls es ein untergeordnetes Element ist) an der durch mode angegebenen Position befindet. mode kann eine oder eine der folgenden Kombinationen sein:

Wenn keine vertikale Ausrichtung angegeben ist, wird die vertikale Positionierung ignoriert. Das Gleiche 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 Kindelement dazu führen würde, dass am Anfang oder Ende des Flickable leerer Raum angezeigt wird, 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)

Ändert die Größe des Inhalts auf width x height über center.

Dadurch wird der Inhalt des Flickable nicht skaliert, sondern nur die Größe von contentWidth und contentHeight geändert.

Die Größenänderung des Inhalts kann dazu führen, dass der Inhalt 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 innerhalb der zulässigen Grenzen liegt.

Diese Funktion kann aufgerufen werden, um sicherzustellen, dass der Inhalt innerhalb der zulässigen Grenzen liegt, nachdem der Inhalt manuell positioniert wurde.