HoverHandler QML Type

Manejador para mouse y tablet hover. Más...

• Lista de todos los miembros, incluidos los heredados

Propiedades

• acceptedDevices : flags
• acceptedModifiers : flags
• acceptedPointerTypes : flags
• active : bool
• blocking : bool (since 6.3)
• cursorShape : Qt::CursorShape
• enabled : bool
• grabPermissions : flags
• hovered : bool
• margin : real
• parent : Item
• point : handlerPoint
• target : Item

Señales

• canceled(eventPoint point)
• grabChanged(PointerDevice::GrabTransition transition, eventPoint point)

Descripción detallada

HoverHandler detecta el cursor del ratón o de la tableta.

Un enlace a la propiedad hovered es la forma más sencilla de reaccionar cuando el cursor entra o sale del elemento parent. La propiedad point proporciona más detalles, incluida la posición del cursor. Las propiedades acceptedDevices, acceptedPointerTypes, y acceptedModifiers se pueden utilizar para limitar el comportamiento y detectar el movimiento del cursor en determinados tipos de dispositivos o mientras se mantiene pulsada una tecla modificadora.

La propiedad cursorShape permite cambiar el cursor siempre que hovered cambie a true.

Véase también MouseArea, PointHandler, y Qt Quick Ejemplos - Manejadores de puntero.

Documentación de propiedades

acceptedDevices : flags

Los tipos de dispositivos señaladores que pueden activar el manejador de punteros.

Por defecto, esta propiedad se establece en PointerDevice.AllDevices. Si se establece en una combinación OR de tipos de dispositivos, se ignorarán los eventos de puntero de los dispositivos no coincidentes.

Por ejemplo, se puede hacer que un elemento responda al puntero del ratón de una manera y al puntero del lápiz de otra, con dos manejadores:

import QtQuick

Rectangle {
    width: 150; height: 50; radius: 3
    color: mouse.hovered ? "goldenrod" : stylus.hovered ? "tomato" : "wheat"

    HoverHandler {
        id: stylus
        acceptedDevices: PointerDevice.Stylus
        cursorShape: Qt.CrossCursor
    }

    HoverHandler {
        id: mouse
        acceptedDevices: PointerDevice.Mouse | PointerDevice.TouchPad
        cursorShape: Qt.PointingHandCursor
    }
}

Los tipos de dispositivo disponibles son los siguientes:

Véase también QInputDevice::DeviceType.

acceptedModifiers : flags

Si se establece esta propiedad, un evento hover se gestiona sólo si se pulsan los modificadores de teclado dados. El evento es ignorado sin los modificadores.

Esta propiedad está establecida a Qt.KeyboardModifierMask por defecto, lo que resulta en el manejo de eventos hover independientemente de cualquier tecla modificadora.

Por ejemplo, un Item podría tener dos manejadores del mismo tipo, uno de los cuales sólo se activa si se pulsan los modificadores de teclado requeridos:

import QtQuick

Rectangle {
    width: 150; height: 50; radius: 3
    color: control.hovered ? "goldenrod" : shift.hovered ? "wheat" : "beige"

    HoverHandler {
        id: control
        acceptedModifiers: Qt.ControlModifier
        cursorShape: Qt.PointingHandCursor
    }

    HoverHandler {
        id: shift
        acceptedModifiers: Qt.ShiftModifier
        cursorShape: Qt.CrossCursor
    }
}

Los modificadores disponibles son los siguientes:

Véase también Qt::KeyboardModifier.

acceptedPointerTypes : flags

Los tipos de instrumentos señaladores (genérico, stylus, borrador, etc.) que pueden activar el manejador de puntero.

Por defecto, esta propiedad está establecida en PointerDevice.AllPointerTypes. Si la establece en una combinación OR de tipos de dispositivos, ignorará los eventos de los que no coincidan.

Por ejemplo, podría proporcionar retroalimentación cambiando el cursor dependiendo de si un lápiz o un borrador se cierne sobre una tableta gráfica:

import QtQuick

Rectangle {
    id: rect
    width: 150; height: 150

    HoverHandler {
        id: stylus
        acceptedPointerTypes: PointerDevice.Pen
        cursorShape: Qt.CrossCursor
    }

    HoverHandler {
        id: eraser
        acceptedPointerTypes: PointerDevice.Eraser
        cursorShape: Qt.BlankCursor
        target: Image {
            parent: rect
            source: "images/cursor-eraser.png"
            visible: eraser.hovered
            x: eraser.point.position.x
            y: eraser.point.position.y - 32
        }
    }
}

Los tipos de puntero disponibles son los siguientes

Véase también QPointingDevice::PointerType.

active : bool [read-only]

Esto se mantiene true siempre que este Manejador de Entrada haya tomado la responsabilidad exclusiva de manejar uno o más eventPoints, tomando con éxito un agarre exclusivo de esos puntos. Esto significa que está manteniendo sus propiedades actualizadas de acuerdo con los movimientos de esos eventPoints y manipulando activamente su target (si existe).

blocking : bool [since 6.3]

Si este manejador previene que otros ítems o manejadores detrás de él sean rondados al mismo tiempo. Esta propiedad es false por defecto.

Esta propiedad se introdujo en Qt 6.3.

cursorShape : Qt::CursorShape

Esta propiedad contiene la forma del cursor que aparecerá siempre que hovered sea true y no haya otro manejador que lo sobrescriba.

Las formas de cursor disponibles son:

• Qt.ArrowCursor
• Qt.UpArrowCursor
• Qt.CursorCruzado
• Qt.WaitCursor
• Qt.IBeamCursor
• Qt.SizeVerCursor
• Qt.SizeHorCursor
• Qt.SizeBDiagCursor
• Qt.SizeFDiagCursor
• Qt.SizeAllCursor
• Qt.BlankCursor
• Qt.SplitVCursor
• Qt.SplitHCursor
• Qt.PointingHandCursor
• Qt.ForbiddenCursor
• Qt.WhatsThisCursor
• Qt.BusyCursor
• Qt.OpenHandCursor
• Qt.CursorManoCerrada
• Qt.DragCopyCursor
• Qt.DragMoveCursor
• Qt.DragLinkCursor

El valor por defecto de esta propiedad no está establecido, lo que permite a cualquier manejador activo sobre el mismo ítem padre determinar la forma del cursor. Esta propiedad puede ser restablecida a la condición inicial estableciéndola a undefined.

Si cualquier manejador con cursorShape definido es active, ese cursor aparecerá. Si el HoverHandler tiene un cursorShape definido, ese cursor aparecerá. En caso contrario, aparecerá el cursor del elemento padre.

Véase también Qt::CursorShape y QQuickItem::cursor().

enabled : bool

Si un HoverHandler está desactivado, rechazará todos los eventos y no se emitirá ninguna señal.

Si un HoverHandler's parent es disabled, el HoverHandler continúa reaccionando a los eventos hover por defecto. Esto se debe a que los efectos de retroalimentación hover y los tooltips pueden ser útiles incluso cuando un control está desactivado. Si quieres deshabilitar el HoverHandler cuando su padre está deshabilitado, puedes añadir un binding:

Item {
    HoverHandler {
        enabled: parent.enabled
    }
}

grabPermissions : flags

Esta propiedad especifica los permisos cuando la lógica de este manejador decide hacerse cargo de la toma exclusiva, o cuando se le pide que apruebe la toma o cancelación de la toma por parte de otro manejador.

El valor predeterminado es PointerHandler.CanTakeOverFromItems | PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByAnything que permite la mayoría de los escenarios de toma, pero evita, por ejemplo, dos PinchHandlers luchando por los mismos puntos de contacto.

hovered : bool [read-only]

Se mantiene siempre que el cursor de cualquier dispositivo señalador (ratón o tableta) se encuentre dentro de los límites del elemento parent, ampliados por margin, si existe.

margin : real

El margen más allá de los límites del elemento parent dentro del cual un eventPoint puede activar este manejador. Por ejemplo, en un PinchHandler en el que el target es también el parent, es útil establecerlo a una distancia de al menos la mitad de la anchura del dedo de un usuario típico, de modo que si el parent se ha reducido a un tamaño muy pequeño, el gesto de pellizcar siga siendo posible. O, si se coloca un botón basado en TapHandler cerca del borde de la pantalla, puede utilizarse para cumplir la Ley de Fitts: reaccionar a los clics del ratón en el borde de la pantalla aunque el botón esté visualmente separado del borde por unos pocos píxeles.

El valor por defecto es 0.

parent : Item

El Item que es el ámbito del manejador; el Item en el que fue declarado. El manejador manejará eventos en nombre de este Item, lo que significa que un evento de puntero es relevante si al menos uno de sus eventPoints ocurre dentro del interior del Item. Inicialmente target() es el mismo, pero puede ser reasignado.

Véase también target y QObject::parent().

point : handlerPoint [read-only]

El eventPoint que se está manejando actualmente. Cuando no se está gestionando ningún punto, este objeto se restablece a los valores por defecto (todas las coordenadas son 0).

target : Item

Elemento que manipulará este controlador.

Por defecto, es el mismo que parent, el Item dentro del cual se declara el manejador. Sin embargo, a veces puede ser útil establecer el objetivo a un Item diferente, para manejar eventos dentro de un item pero manipular otro; o a null, para desactivar el comportamiento por defecto y hacer otra cosa en su lugar.

Documentación sobre señales

canceled(eventPoint point)

Si este manejador ya ha agarrado el point dado, esta señal es emitida cuando el agarre es robado por un Manejador de Punteros o Item diferente.

grabChanged(PointerDevice::GrabTransition transition, eventPoint point)

Esta señal se emite cuando la cuchara ha cambiado de alguna manera que es relevante para este controlador.

El transition (verbo) dice lo que ha pasado. El point (objeto) es el punto que fue agarrado o no agarrado.

Los valores válidos para transition son: