Flickable QML Type

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.

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.

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

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.

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

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.

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

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

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

Diese Eigenschaft gibt an, ob die Oberfläche über die Grenzen des Flickable hinaus gezogen werden kann oder ob sie beim Streichen über die Grenzen des Flickable hinausgeht.

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.

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

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.

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

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

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 Eigenschaft gibt die Geschwindigkeit an, mit der ein Flick verlangsamt wird: je höher die Zahl, desto schneller wird er verlangsamt, wenn der Benutzer aufhört, durch Berührung zu flicken. Zum Beispiel ist 0.0001 fast "reibungslos", und 10000 fühlt sich ziemlich "klebrig" an.

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

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

• Flickable.AutoFlickDirection (Standard) - erlaubt vertikales Kippen, wenn die 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. Erlaubt horizontales Flackern, wenn contentWidth größer ist als die Breite des Flickable. (seit QtQuick 2.7)
• Flickable.HorizontalFlick - ermöglicht horizontales Flackern.
• Flickable.VerticalFlick - erlaubt vertikales Flackern.
• Flickable.HorizontalAndVerticalFlick - erlaubt das Flackern in beide Richtungen.

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 gezogen wurde; ansonsten ist er 0.0.

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

Siehe auch verticalOvershoot, boundsBehavior, und boundsMovement.

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 besondere Interaktion mit den untergeordneten Elementen von Flickable, z. B. wenn Sie eine flickbare Karte einfrieren möchten, während Sie durch einen Popup-Dialog blättern, der ein untergeordnetes Element von Flickable ist.

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

Der Standardwert ist plattformabhängig.

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. Linien mit einer Breite von einem Pixel, Text oder Vektorgrafiken. Deaktivieren Sie pixelAligned, wenn Sie die Qualität von Animationen optimieren wollen.

Die Standardeinstellung ist false.

Diese Eigenschaft enthält die Verzögerungszeit (ms), mit der ein Druck auf die Kinder des Flickable ausgelöst wird. Dies kann nützlich sein, wenn die Reaktion auf einen Druck vor einer Flick-Aktion unerwünschte Auswirkungen hat.

Wenn das Flickable gezogen/geklickt wird, bevor die Verzögerungszeit abgelaufen ist, 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.

Hier wird der Übergang festgelegt, der auf die Inhaltsansicht angewendet werden soll, wenn sie an den Grenzen des Flickables 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 gesetzt ist, wird eine Standardanimation angewendet.

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 der Inhaltspixel, der sich beim Drücken unter dem Cursor oder Berührungspunkt befand, unter diesem Punkt bleibt.

Die Voreinstellung ist false, die ein sanfteres Erlebnis (kein Sprung) bietet, allerdings um den Preis, dass ein Teil der Ziehdistanz am Anfang "verloren" geht.

Diese Eigenschaft gibt die vertikale Überschreitung an, 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 gezogen wurde; andernfalls ist er 0.0.

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

Siehe auch horizontalOvershoot, boundsBehavior, und boundsMovement.

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"
    }
}

Dieses Signal wird ausgegeben, wenn der Benutzer das Ziehen der Ansicht beendet.

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

Dieses Signal wird ausgegeben, wenn die Ansicht aufgrund einer Benutzerinteraktion zu ziehen beginnt.

Dieses Signal wird ausgegeben, wenn sich die Ansicht nach einer Bewegung oder einer Reihe von Bewegungen nicht mehr bewegt.

Dieses Signal wird ausgegeben, wenn die Ansicht geschnipst wird. Ein Streichen beginnt an dem Punkt, an dem die Maus oder die Berührung losgelassen wird, während sie noch in Bewegung ist.

Dieses Signal wird ausgegeben, wenn die Ansicht aufgrund einer Benutzerinteraktion oder eines generierten flick() die Bewegung stoppt. Wenn ein Flick aktiv war, wird dieses Signal ausgegeben, sobald der Flick stoppt. 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.

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

Bricht die aktuelle Flick-Animation ab.

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

Durch den Aufruf dieser Methode werden die entsprechenden Eigenschaften und Signale für das Bewegen und Streichen aktualisiert, genau wie bei einem echten Streichen auf dem Touchscreen.

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

Dadurch wird der Inhalt des Flickable nicht skaliert - es wird 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 positioniert.

Stellt sicher, dass der Inhalt innerhalb der zulässigen Grenzen liegt.

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