QScroller Class

Documentation des fonctions membres

[static] QList<QScroller *> QScroller::activeScrollers()

Renvoie une liste, à l'échelle de l'application, des objets ` QScroller ` actuellement actifs. Les objets ` QScroller ` actifs se trouvent dans un ` state()` qui n'est pas ` QScroller::Inactive`. Cette fonction est utile lorsque vous développez votre propre système de reconnaissance des gestes.

[slot] void QScroller::ensureVisible(const QRectF &rect, qreal xmargin, qreal ymargin)

Le défilement démarre de manière à ce que le rectangle rect soit visible dans la fenêtre d'affichage, avec des marges supplémentaires spécifiées en pixels par xmargin et ymargin autour du rectangle.

Dans les cas où il n’est pas possible de faire tenir le rectangle et ses marges à l’intérieur de la fenêtre d’affichage, le contenu est défilé de manière à ce que le plus possible de contenu soit visible à partir de rect.

La vitesse de défilement est calculée de manière à ce que la position donnée soit atteinte après un délai défini par la plateforme.

Cette fonction effectue le défilement proprement dit en appelant scrollTo().

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        scroller, qOverload(&QScroller::ensureVisible));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        scroller, [receiver = scroller](const QRectF &rect, qreal xmargin, qreal ymargin) { receiver->ensureVisible(rect, xmargin, ymargin); });

Voir également scrollTo().

[slot] void QScroller::ensureVisible(const QRectF &rect, qreal xmargin, qreal ymargin, int scrollTime)

Cette version atteindra sa position de destination en scrollTime millisecondes.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        scroller, qOverload(&QScroller::ensureVisible));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        scroller, [receiver = scroller](const QRectF &rect, qreal xmargin, qreal ymargin, int scrollTime) { receiver->ensureVisible(rect, xmargin, ymargin, scrollTime); });

QPointF QScroller::finalPosition() const

Renvoie la position finale estimée pour le mouvement de défilement en cours. Renvoie la position actuelle si l'état du défilement n'est pas « Scrolling ». Le résultat est indéfini lorsque l'état du défilement est « Inactive ».

La position cible est exprimée en pixels.

Voir également pixelPerMeter() et scrollTo().

[static] Qt::GestureType QScroller::grabGesture(QObject *target, QScroller::ScrollerGestureType scrollGestureType = TouchGesture)

Enregistre un détecteur de geste de défilement personnalisé, l'associe à l'target et renvoie le type de geste obtenu. Si le paramètre « scrollGestureType » est défini sur « TouchGesture », le geste se déclenche lors d'événements tactiles. S'il est défini sur l'une des valeurs suivantes : « LeftMouseButtonGesture », « RightMouseButtonGesture » ou « MiddleMouseButtonGesture », il se déclenche lors d'événements de souris sur le bouton correspondant.

Un seul geste de défilement peut être actif à la fois sur un même objet. Si vous appelez cette fonction deux fois sur le même objet, elle annulera le geste existant avant d’en activer un nouveau.

Voir également ungrabGesture() et grabbedGesture().

[static] Qt::GestureType QScroller::grabbedGesture(QObject *target)

Renvoie le type de geste actuellement capturé pour l'target, ou 0 si aucun geste n'est capturé.

Voir aussi grabGesture() et ungrabGesture().

bool QScroller::handleInput(QScroller::Input input, const QPointF &position, qint64 timestamp = 0)

Cette fonction est utilisée par les systèmes de reconnaissance gestuelle pour signaler au scroller un nouvel événement d’entrée. Le scroller modifie son « state() » interne en fonction de l’événement d’entrée et des propriétés qui lui sont associées. Le scroller ne fait aucune distinction quant au type de périphérique d’entrée à l’origine de l’événement. Par conséquent, l’événement doit être décomposé en un type « input », un « position » et une « timestamp » exprimée en millisecondes. La « position » doit être exprimée dans le système de coordonnées de la cible.

La valeur renvoyée est « true » si l’événement doit être traité par le filtre appelant, ou « false » s’il doit être transmis au contrôle.

[static] bool QScroller::hasScroller(QObject *target)

Renvoie « true » si un objet « QScroller » a déjà été créé pour « target » ; « false » dans le cas contraire.

Voir aussi scroller().

QPointF QScroller::pixelPerMeter() const

Renvoie la mesure « pixels par mètre » pour le widget défilant.

La valeur est indiquée séparément pour les axes x et y à l'aide d'un QPointF.

[slot] void QScroller::resendPrepareEvent()

Cette fonction renvoie l'événement « QScrollPrepareEvent ». L'appel de la fonction `resendPrepareEvent` déclenche un événement « QScrollPrepareEvent » depuis le défilement. Cela permet au récepteur de redéfinir la position et la taille du contenu pendant le défilement. L'appel de cette fonction lorsque l'élément est à l'état « Inactive » est inutile, car l'événement « prepare » est renvoyé avant le début du défilement.

[slot] void QScroller::scrollTo(const QPointF &pos)

Lance le défilement du widget de manière à ce que le point pos se trouve en haut à gauche de la fenêtre d'affichage.

Le comportement en cas de défilement en dehors de la zone de défilement valide n'est pas défini. Dans ce cas, le défilement peut ou non dépasser la limite.

La vitesse de défilement sera calculée de manière à ce que la position indiquée soit atteinte après un laps de temps défini par la plateforme.

pos est exprimée en coordonnées de la fenêtre d'affichage.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        scroller, qOverload(&QScroller::scrollTo));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        scroller, [receiver = scroller](const QPointF &pos) { receiver->scrollTo(pos); });

Voir également ensureVisible().

[slot] void QScroller::scrollTo(const QPointF &pos, int scrollTime)

Cette version atteindra sa position de destination en scrollTime s de millisecondes.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        scroller, qOverload(&QScroller::scrollTo));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        scroller, [receiver = scroller](const QPointF &pos, int scrollTime) { receiver->scrollTo(pos, scrollTime); });

[static] QScroller *QScroller::scroller(QObject *target)

Renvoie le scroller associé à l'target donné. Tant que l'objet existe, cette fonction renverra toujours la même instance de QScroller. Si aucun QScroller n'existe pour l'target, il en sera implicitement créé un. À aucun moment, il n'y aura plus d'un QScroller actif sur un objet.

Voir également hasScroller() et target().

[static] const QScroller *QScroller::scroller(const QObject *target)

Il s'agit de la version « const » de la fonction scroller().

[signal] void QScroller::scrollerPropertiesChanged(const QScrollerProperties &newProperties)

QScroller émet ce signal chaque fois que les propriétés de son défilement changent. newProperties correspondent aux nouvelles propriétés du défilement.

Voir également scrollerProperties.

void QScroller::setSnapPositionsX(const QList<qreal> &positions)

Définissez les positions d'alignement de l'axe horizontal à l'aide d'une liste de valeurs de type ` positions`. Cela remplace toutes les positions d'alignement précédemment définies, ainsi que l'intervalle d'alignement précédemment défini. L'alignement peut être désactivé en définissant une liste vide de positions.

void QScroller::setSnapPositionsX(qreal first, qreal interval)

Définissez les positions d'accrochage de l'axe horizontal à des intervalles réguliers. La première position d'accrochage se trouve à first. La suivante à first + interval. Cela permet de créer un en-tête de liste. Cette opération remplace toutes les positions d'accrochage précédemment définies, ainsi que l'intervalle d'accrochage précédemment défini. L'accrochage peut être désactivé en définissant un intervalle de 0,0.

void QScroller::setSnapPositionsY(const QList<qreal> &positions)

Définissez les positions d'accrochage de l'axe vertical en spécifiant une liste de positions positions. Cela remplace toutes les positions d'accrochage définies précédemment, ainsi que l'intervalle d'accrochage éventuellement défini auparavant. L'accrochage peut être désactivé en définissant une liste vide de positions.

void QScroller::setSnapPositionsY(qreal first, qreal interval)

Définissez les positions d'accrochage de l'axe vertical à des intervalles réguliers. La première position d'accrochage se trouve à first. La suivante à first + interval. Cela remplace toutes les positions d'accrochage définies précédemment, ainsi que l'intervalle d'accrochage précédemment défini. L'accrochage peut être désactivé en définissant un intervalle de 0,0.

[signal] void QScroller::stateChanged(QScroller::State newState)

QScroller émet ce signal chaque fois que l'état change. newState correspond au nouvel état.

Voir également state.

void QScroller::stop()

Arrête le défilement et rétablit son état à « Inactif ».

QObject *QScroller::target() const

Renvoie l'objet cible de ce défilement.

Voir également hasScroller() et scroller().

[static] void QScroller::ungrabGesture(QObject *target)

Libère le geste pour l'target. Ne fait rien si aucun geste n'est capturé.

Voir également grabGesture() et grabbedGesture().

QPointF QScroller::velocity() const

Renvoie la vitesse de défilement actuelle en mètres par seconde lorsque l'état est « Scrolling » (Défilement) ou « Dragging » (Glissement). Dans le cas contraire, renvoie une vitesse égale à zéro.

La vitesse est indiquée séparément pour les axes x et y à l'aide de la fonction ` QPointF`.

Voir également pixelPerMeter().