Qt. ¿Como propagar eventos de escena del raton a items?

[dehm]

Hola:

Ando enredando con el tema de QGraphicsView/QGraphicsScene/QGraphicsItem

He visto este ejemplo: http://www.walletfox.com/course/qgra...imedrawing.php
y siguiendo la idea he ido añadiendo items (circulos) y una cruceta tipo autoCAD

Pero ahora que me voy enterando de cómo funciona, he querido empezar a separar cosas.
Codigo fuente aquí

Ahora, el problema que tengo es que necesito que los eventos del ratón se me propaguen a los items, y no sé cómo hacerlo.

Por ejemplo, en el código que tengo y que se puede ver en el enlace, la cruceta son dos QGraphicsLineItem, que responden al movimiento del ratón así:

Código C++:

void Scene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    ejeX->setLine(0,event->scenePos().y(),800,event->scenePos().y());
    ejeY->setLine(event->scenePos().x(),0,event->scenePos().x(),600);
------------------
(Aqui sigue actuando el evento)
}
 

Ahora, cuando pretendo que la cruceta sea un objeto propio, sólo se me ocurre lo siguiente para propagar el evento al objeto Cursor:

Código C++:

void Scene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
   Cruceta->mouseMoveEvent(event);
------------------
(Aqui sigue actuando el evento)
}
 

Pero a esta "solución" le veo dos fallos:
1.- Me obliga a declarar los métodos de eventos en la clase Cursor (la clase que crea la cruceta) como públicos, cuando son métodos que debería ser protected, ya que son reimplementaciones de la clase QGraphicsItem
2.- No me acepta el método setMouseTracking(bool); , o al menos no funciona

Llevo toda la tarde viendo este ejemplo:
http://doc.qt.io/qt-5/qtwidgets-grap...e-example.html

Y hasta donde he podido entender, es el método QMouseMoveEvent de la propìa escena el que actúa de una u otra forma según el modo en el que esté (edicion, inserción, etc), lo que me lleva a pensar que lo que yo quiero debe de ser un error de diseño, o de concepto, y que supongo que no debería intentar ir por ahí.
Pero bueno, se aceptan sugerencias
Gracias como siempre

[dehm]

Bueno, se me acaba de ocurrir algo, pero aunque funciona, creo que sigo sin ir por la buena dirección.

Se trata de crear una función en el item, que se llama mover, y que recoge el punto actual:

Código C++:

void Cursor::mover(QPointF punto)
{
    posicionActual=punto;
    EjeX.setLine(0,punto.y(),ancho,punto.y());
    EjeY.setLine(punto.x(),0,punto.x(),alto);   
    update();
}
 

esta función se encarga de llamar al método paint().....

Y luego, en la clase de la scena:

Código C++:

void Scene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{  
    Cruceta->mover(event->scenePos());
-------------------------
mas cosas
}
 

El caso es que así funciona, pero no sé si es la forma correcta.

[eferion]

Dado que el objeto Cruceta no es un QWidget no tiene "presencia" en el formulario, luego no puede recibir eventos directamente. Digamos que lo que sucede es que tu "pintas" el objeto de forma explícita, de tal forma que el contenedor no sabe que en esas coordenadas hay un objeto al que deba pasarle eventos.

Tienes varias soluciones:

Usar señales

Puedes crear una señal en el objeto escena que exponga el evento que te interesa, en este caso mouseMove. Entonces simplemente haces un connect para cada objeto que deba conocer ese evento y listo:

Código C++:

class Cruceta
  : public QObject // necesario para los eventos.
                   // Se puede sustituir por cualquier objeto que herede de QObject
{
  Q_OBJECT // necesario para los eventos
 
    public slot:
      void MouseMove(QGraphicsSceneMouseEvent *event)
      { }
};
 
class Scene // Por qué cruceta en español y scene en inglés???
{
  signals:
    // Recuerda que las señales no tienen implementación, de eso se encarga qt.
    void OnMouseMove(QGraphicsSceneMouseEvent *event);
};
 
void Scene::Scene(...)
{
  // O como se llame tu objeto, tampoco es necesario que se cree aquí
  cruceta = new Cruceta(...);
 
  // Eso sí, esto hay que hacerlo después de crear tu objeto cruceta
  connect(this, SIGNAL(OnMouseMove(QGraphicsSceneMouseEvent*)),
          cruceta, SLOT(MouseMove(QGraphicsSceneMouseEvent*)));
}
 
void Scene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    emit OnMouseMove(event); // Emitimos la señal
 
    // ------------------
    // (Aqui sigue actuando el evento)
}
 

Usar el patrón observer

Esta solución es similar a la anterior pero basada en C++ puro.

Necesitas una clase base para los suscriptores de los eventos. Lo ideal es que sea una clase virtual pura para reducir acoplamientos:

Código C++:

class Subscriber
{
  public:
    void MouseMove(QGraphicsSceneMouseEvent* event) = 0;
};
 

El siguiente paso es hacer que tu objeto Cruceta herede de esta nueva clase. Como Subscriber es virtual pura no te debería ocasionar muchos problemas si tienes que recurrir a la herencia múltiple:

Código C++:

class Cruceta
 : public Subscriber, /* Tus propias herencias */
{
  public:
    void MouseMove(QGraphicsSceneMouseEvent* event ) override
    { }
};
 

Y para terminar metemos mano al objeto Scene. Una forma de resolver esta papeleta consiste en tener una lista de suscriptores, así se puede propagar el evento con un simple bucle:

Código C++:

class Scene
{
  std::vector<Subscriber*> _subscribers;
 
  public:
    Scene()
    {
       _cruceta = new Cruceta;
       
       Attach(_cruceta);
    }
 
    void Attach(Subscriber* newSubscriber)
    { _subscribers.push_back(newSubscriber); }
 
    void MouseMove(QGraphicsSceneMouseEvent* event)
    {
      // la segunda línea es una lambda, no te asustes :)
      std::for_each(_subscribers.begin(),_subscribers.end(),
                    [event](Subscriber* ptr) { ptr->MouseMove(event); });
    }
};
 

Cualquiera de estos dos mecanismos te permite separar ambas capas de código. La única diferencia es que la primera solución aprovecha las capacidades de Qt mientras que en la segunda lo tienes que cocinar todo a mano :)

Un saludo

[dehm]

Hola eferion, como siempre, muchas gracias por responder.

Pero antes de meterme a fondo con tu respuesta (me puedo pasar todo el día para entender el código en su totalidad...ojalá tuviera tu nivel ) te pregunto:

Cuando dices que el objeto Cruceta no es un QWidget y que no tiene "presencia" en el formulario, te refieres al QGraphicsView como ese QWidget?

Por otro lado, en el momento en el que la cruceta hereda de QGraphicsItem y la añado a la escena....¿no debería ser ser receptora de los eventos del ratón de la escena? Bueno, está claro que no es así...

En fin, como ves no tengo los conceptos muy claros

[dehm]

Bueno, ya me he visto tu primera propuesta.
La idea es parecida a mi "solución" pero bien hecha.

Lo que pasa es que esto me obliga a que la clase Cruceta herede de QGraphicsItem y de QObject.....creo que nunca he hecho una herencia múltiple Voy a probar, siempre tiene que haber una primera vez.

Por cierto, sobre los nombre en inglés y español...como parto de un código copiado, se pueden ver nombres en inglés. He querido mantenerlos así y mis primeros añadidos iban en inglés, pero al final la cabra siempre tira al monte y he terminado en español

[eferion]

Iniciado por dehm

Cuando dices que el objeto Cruceta no es un QWidget y que no tiene "presencia" en el formulario, te refieres al QGraphicsView como ese QWidget?

Vamos a bajar un momento a nivel de API de windows. No hay que perder de vista que los controles gráficos de Qt acaban pasando antes o después por este punto.

Cada control de usuario (que son sensibles al teclado y al ratón) se crea haciendo uso de una función especial de la api de windows:

• CreateWindow
• CreateWindowEx

Estas funciones dan de alta una nueva zona "sensible" en la memoria de la pantalla.

Cuando el usuario, con el ratón, hace click en un punto de la pantalla, el evento es gestionado en primera instancia por el sistema operativo. Éste comprueba sobre qué region "sensible" se ha lanzado el evento. A partir de ese dato encuentra qué aplicación es la responsable de dicha región. Con esta información, el SO avisa a la aplicación sobre el nuevo evento... la aplicación entonces recibe el evento y lo acaba canalizando hasta que llega al control pertinente.

¿Por qué te cuento todo este coñazo? Por una sencilla razón: Si tu delegas la responsabilidad de pintar un componente añadiendo dicho componente a un contenedor (un diálogo, un layout, ...), se acaba creando una región "sensible" que será susceptible de recibir eventos del teclado y el ratón. Si tu pintas "a mano" un control... eso no es más que una serie de trazos en pantalla que no están asociados a nada, luego esa representación no va a recibir en la vida un evento del sistema operativo.

Espero que, tostonazo aparte, haya quedado un poco más claro el tema de los controles de usuario y los eventos :)