Ejemplo de nodos elásticos
Muestra cómo interactuar con elementos gráficos en una escena.
El ejemplo «Nodos elásticos» muestra cómo implementar aristas entre nodos en un grafo, con interacción básica. Puedes hacer clic para arrastrar un nodo y acercar o alejar la imagen con la rueda del ratón o el teclado. Al pulsar la barra espaciadora, los nodos se ordenarán aleatoriamente. El ejemplo también es independiente de la resolución; al acercar la imagen, los gráficos se mantienen nítidos.

Graphics View proporciona la clase ` QGraphicsScene ` para gestionar e interactuar con un gran número de elementos gráficos 2D personalizados derivados de la clase ` QGraphicsItem `, así como un widget ` QGraphicsView ` para visualizar los elementos, con soporte para el zoom y la rotación.
Este ejemplo consta de una clase ` Node `, una clase ` Edge `, una prueba ` GraphWidget ` y una función ` main `: la clase ` Node ` representa nodos amarillos arrastrables en una cuadrícula, la clase ` Edge ` representa las líneas entre los nodos, la clase ` GraphWidget ` representa la ventana de la aplicación y la función ` main() ` crea y muestra esta ventana, además de ejecutar el bucle de eventos.
Definición de la clase Node
La clase « Node » tiene tres funciones:
- Dibujar una «bola» con degradado amarillo en dos estados: hundida y elevada.
- Gestionar las conexiones con otros nodos.
- Calcular las fuerzas que empujan y tiran de los nodos en la cuadrícula.
Empecemos por examinar la declaración de la clase ` Node `.
class Node : public QGraphicsItem
{
public:
Node(GraphWidget *graphWidget);
void addEdge(Edge *edge);
QList<Edge *> edges() const;
enum { Type = UserType + 1 };
int type() const override { return Type; }
void calculateForces();
bool advancePosition();
QRectF boundingRect() const override;
QPainterPath shape() const override;
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
protected:
QVariant itemChange(GraphicsItemChange change, const QVariant &value) override;
void mousePressEvent(QGraphicsSceneMouseEvent *event) override;
void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
private:
QList<Edge *> edgeList;
QPointF newPos;
GraphWidget *graph;
};La clase « Node » hereda de « QGraphicsItem » y reimplementa las dos funciones obligatorias « boundingRect()» y « paint()» para definir su apariencia visual. También reimplementa « shape()» para garantizar que su área de impacto tenga forma elíptica (en lugar del rectángulo delimitador predeterminado).
A efectos de la gestión de aristas, el nodo proporciona una API sencilla para añadir aristas a un nodo y para enumerar todas las aristas conectadas.
La reimplementación de ` advance()` se invoca cada vez que el estado de la escena avanza un paso. Se invoca la función `calculateForces()` para calcular las fuerzas que empujan y tiran de este nodo y de sus vecinos.
La clase ` Node ` también reimplementa ` itemChange()` para reaccionar ante los cambios de estado (en este caso, cambios de posición), así como ` mousePressEvent()` y ` mouseReleaseEvent()` para actualizar el aspecto visual del elemento.
Comenzaremos a revisar la implementación de ` Node ` analizando su constructor:
Node::Node(GraphWidget *graphWidget)
: graph(graphWidget)
{
setFlag(ItemIsMovable);
setFlag(ItemSendsGeometryChanges);
setCacheMode(DeviceCoordinateCache);
setZValue(-1);
}En el constructor, establecemos el indicador ` ItemIsMovable ` para permitir que el elemento se mueva al arrastrarlo con el ratón, y ` ItemSendsGeometryChanges ` para habilitar las notificaciones de ` itemChange()` ante cambios de posición y transformación. También habilitamos ` DeviceCoordinateCache ` para acelerar el rendimiento del renderizado. Para garantizar que los nodos siempre se superpongan a las aristas, por último establecemos el valor Z del elemento en -1.
NodeEl constructor de `` toma un puntero ` GraphWidget ` y lo almacena como variable miembro. Volveremos sobre este puntero más adelante.
void Node::addEdge(Edge *edge)
{
edgeList << edge;
edge->adjust();
}
QList<Edge *> Node::edges() const
{
return edgeList;
}La función addEdge() añade el borde de entrada a una lista de bordes adjuntos. A continuación, se ajusta el borde para que sus extremos coincidan con las posiciones de los nodos de origen y destino.
La función edges() simplemente devuelve la lista de aristas adjuntas.
void Node::calculateForces()
{
if (!scene() || scene()->mouseGrabberItem() == this) {
newPos = pos();
return;
}Hay dos formas de mover un nodo. La función ` calculateForces() ` implementa el efecto elástico que tira y empuja de los nodos en la cuadrícula. Además, el usuario puede mover directamente un nodo con el ratón. Como no queremos que ambos métodos actúen al mismo tiempo sobre el mismo nodo, en calculateForces() comprobamos primero si este Node es el elemento seleccionado actualmente con el ratón (es decir, QGraphicsScene::mouseGrabberItem()). Dado que necesitamos encontrar todos los nodos vecinos (aunque no necesariamente conectados), también nos aseguramos de que el elemento forme parte de una escena.
// Sum up all forces pushing this item away
qreal xvel = 0;
qreal yvel = 0;
const QList<QGraphicsItem *> items = scene()->items();
for (QGraphicsItem *item : items) {
Node *node = qgraphicsitem_cast<Node *>(item);
if (!node)
continue;
QPointF vec = mapToItem(node, 0, 0);
qreal dx = vec.x();
qreal dy = vec.y();
double l = 2.0 * (dx * dx + dy * dy);
if (l > 0) {
xvel += (dx * 150.0) / l;
yvel += (dy * 150.0) / l;
}
}El efecto «elástico» se debe a un algoritmo que aplica fuerzas de empuje y tracción. El efecto es impresionante y, sorprendentemente, sencillo de implementar.
El algoritmo consta de dos pasos: el primero consiste en calcular las fuerzas que separan los nodos, y el segundo, en restar las fuerzas que los unen. En primer lugar, debemos encontrar todos los nodos del grafo. Llamamos a QGraphicsScene::items() para encontrar todos los elementos de la escena y, a continuación, utilizamos qgraphicsitem_cast() para buscar instancias de Node.
Utilizamos mapFromItem() para crear un vector temporal que apunta desde este nodo hacia cada uno de los demás nodos, en coordenadas locales. Empleamos las componentes descompuestas de este vector para determinar la dirección y la intensidad de la fuerza que debe aplicarse al nodo. Las fuerzas se acumulan para cada nodo y, a continuación, se ajustan de modo que los nodos más cercanos reciban la fuerza más intensa, con una rápida disminución a medida que aumenta la distancia. La suma de todas las fuerzas se almacena en xvel (velocidad X) y yvel (velocidad Y).
// Now subtract all forces pulling items together
double weight = (edgeList.size() + 1) * 10;
for (const Edge *edge : std::as_const(edgeList)) {
QPointF vec;
if (edge->sourceNode() == this)
vec = mapToItem(edge->destNode(), 0, 0);
else
vec = mapToItem(edge->sourceNode(), 0, 0);
xvel -= vec.x() / weight;
yvel -= vec.y() / weight;
}Las aristas entre los nodos representan fuerzas que atraen a los nodos entre sí. Al examinar cada arista conectada a este nodo, podemos utilizar un enfoque similar al anterior para hallar la dirección y la intensidad de todas las fuerzas de tracción. Estas fuerzas se restan de xvel y yvel.
En teoría, la suma de las fuerzas de empuje y tracción debería estabilizarse exactamente en 0. Sin embargo, en la práctica, esto nunca ocurre. Para evitar errores de precisión numérica, simplemente forzamos que la suma de las fuerzas sea 0 cuando son inferiores a 0,1.
QRectF sceneRect = scene()->sceneRect();
newPos = pos() + QPointF(xvel, yvel);
newPos.setX(qMin(qMax(newPos.x(), sceneRect.left() + 10), sceneRect.right() - 10));
newPos.setY(qMin(qMax(newPos.y(), sceneRect.top() + 10), sceneRect.bottom() - 10));
}El paso final de calculateForces() determina la nueva posición del nodo. Sumamos la fuerza a la posición actual del nodo. También nos aseguramos de que la nueva posición se mantenga dentro de los límites que hemos definido. En realidad, no movemos el elemento en esta función; eso se hace en un paso aparte, desde advance().
bool Node::advancePosition()
{
if (newPos == pos())
return false;
setPos(newPos);
return true;
}La función ` advance() ` actualiza la posición actual del elemento. Se invoca desde ` GraphWidget::timerEvent()`. Si la posición del nodo ha cambiado, la función devuelve `true`; en caso contrario, devuelve `false`.
QRectF Node::boundingRect() const
{
qreal adjust = 2;
return QRectF( -10 - adjust, -10 - adjust, 23 + adjust, 23 + adjust);
}El rectángulo delimitador de Node es un rectángulo de 20x20 centrado en su origen (0, 0), ajustado en 2 unidades en todas las direcciones para compensar el trazo del contorno del nodo, y en 3 unidades hacia abajo y a la derecha para dejar espacio para una sombra simple.
QPainterPath Node::shape() const
{
QPainterPath path;
path.addEllipse(-10, -10, 20, 20);
return path;
}La forma es una elipse sencilla. Esto garantiza que haya que hacer clic dentro de la forma elíptica del nodo para poder arrastrarlo. Puedes probar este efecto ejecutando el ejemplo y ampliando mucho la imagen para que los nodos se vean muy grandes. Sin reimplementar ` shape()` (), el área de selección del elemento sería idéntica a su rectángulo delimitador (es decir, rectangular).
void Node::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *)
{
painter->setPen(Qt::NoPen);
painter->setBrush(Qt::darkGray);
painter->drawEllipse(-7, -7, 20, 20);
QRadialGradient gradient(-3, -3, 10);
if (option->state & QStyle::State_Sunken) {
gradient.setCenter(3, 3);
gradient.setFocalPoint(3, 3);
gradient.setColorAt(1, QColor(Qt::yellow).lighter(120));
gradient.setColorAt(0, QColor(Qt::darkYellow).lighter(120));
} else {
gradient.setColorAt(0, Qt::yellow);
gradient.setColorAt(1, Qt::darkYellow);
}
painter->setBrush(gradient);
painter->setPen(QPen(Qt::black, 0));
painter->drawEllipse(-10, -10, 20, 20);
}Esta función implementa el dibujo del nodo. Comenzamos dibujando una sencilla sombra elíptica de color gris oscuro en (-7, -7), es decir, (3, 3) unidades hacia abajo y a la derecha desde la esquina superior izquierda (-10, -10) de la elipse.
A continuación, dibujamos una elipse con un relleno de degradado radial. Este relleno va de Qt::yellow a Qt::darkYellow cuando está elevado, o al revés cuando está hundido. En el estado hundido, también desplazamos el centro y el punto focal en (3, 3) para acentuar la impresión de que algo ha sido empujado hacia abajo.
Dibujar elipses rellenas con degradados puede resultar bastante lento, especialmente cuando se utilizan degradados complejos como QRadialGradient. Por eso, en este ejemplo se utiliza DeviceCoordinateCache, una medida sencilla pero eficaz que evita redibujados innecesarios.
QVariant Node::itemChange(GraphicsItemChange change, const QVariant &value)
{
switch (change) {
case ItemPositionHasChanged:
for (Edge *edge : std::as_const(edgeList))
edge->adjust();
graph->itemMoved();
break;
default:
break;
};
return QGraphicsItem::itemChange(change, value);
}Reimplementamos itemChange() para ajustar la posición de todos los bordes conectados y para notificar a la escena que un elemento se ha movido (es decir, «ha pasado algo»). Esto desencadenará nuevos cálculos de fuerza.
Esta notificación es la única razón por la que los nodos deben mantener un puntero hacia ` GraphWidget`. Otro enfoque podría consistir en proporcionar dicha notificación mediante una señal; en tal caso, ` Node ` tendría que heredar de ` QGraphicsObject`.
void Node::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
update();
QGraphicsItem::mousePressEvent(event);
}
void Node::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
update();
QGraphicsItem::mouseReleaseEvent(event);
}Como hemos activado el indicador « ItemIsMovable », no necesitamos implementar la lógica que mueve el nodo según la entrada del ratón; esto ya nos viene dado. Sin embargo, aún tenemos que reimplementar los controladores de pulsación y liberación del ratón para actualizar el aspecto visual de los nodos (es decir, hundidos o elevados).
Definición de la clase «Edge»
La clase ` Edge ` representa las líneas en forma de flecha entre los nodos de este ejemplo. La clase es muy sencilla: mantiene un puntero al nodo de origen y otro al de destino, y proporciona una función ` adjust() ` que garantiza que la línea comience en la posición del origen y termine en la del destino. Los bordes son los únicos elementos que cambian continuamente a medida que las fuerzas empujan y tiran de los nodos.
Echemos un vistazo a la declaración de la clase:
class Edge : public QGraphicsItem
{
public:
Edge(Node *sourceNode, Node *destNode);
Node *sourceNode() const;
Node *destNode() const;
void adjust();
enum { Type = UserType + 2 };
int type() const override { return Type; }
protected:
QRectF boundingRect() const override;
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
private:
Node *source, *dest;
QPointF sourcePoint;
QPointF destPoint;
qreal arrowSize = 10;
};Edge hereda de QGraphicsItem, ya que es una clase sencilla que no utiliza señales, ranuras ni propiedades (compárese con QGraphicsObject).
El constructor toma dos punteros a nodos como entrada. Ambos punteros son obligatorios en este ejemplo. También proporcionamos funciones de obtención para cada nodo.
La función adjust() reposiciona el arco, y el elemento también implementa boundingRect() y paint().
A continuación, revisaremos su implementación.
Edge::Edge(Node *sourceNode, Node *destNode)
: source(sourceNode), dest(destNode)
{
setAcceptedMouseButtons(Qt::NoButton);
source->addEdge(this);
dest->addEdge(this);
adjust();
}El constructor de ` Edge ` inicializa su miembro de datos ` arrowSize ` a 10 unidades; esto determina el tamaño de la flecha que se dibuja en ` paint()`.
En el cuerpo del constructor, llamamos a ` setAcceptedMouseButtons(0)`. Esto garantiza que los elementos del borde no se tengan en cuenta en absoluto para la entrada del ratón (es decir, no se puede hacer clic en los bordes). A continuación, se actualizan los punteros de origen y destino, se registra este borde en cada nodo y llamamos a ` adjust() ` para actualizar la posición de inicio y fin de este borde.
Node *Edge::sourceNode() const
{
return source;
}
Node *Edge::destNode() const
{
return dest;
}Las funciones get de origen y destino simplemente devuelven los punteros respectivos.
void Edge::adjust()
{
if (!source || !dest)
return;
QLineF line(mapFromItem(source, 0, 0), mapFromItem(dest, 0, 0));
qreal length = line.length();
prepareGeometryChange();
if (length > qreal(20.)) {
QPointF edgeOffset((line.dx() * 10) / length, (line.dy() * 10) / length);
sourcePoint = line.p1() + edgeOffset;
destPoint = line.p2() - edgeOffset;
} else {
sourcePoint = destPoint = line.p1();
}
}En ` adjust()`, definimos dos puntos: ` sourcePoint` y ` destPoint`, que apuntan a los orígenes de los nodos de origen y destino, respectivamente. Cada punto se calcula utilizando coordenadas locales.
Queremos que la punta de las flechas del borde apunte al contorno exacto de los nodos, en lugar de al centro de los mismos. Para hallar este punto, primero descomponemos el vector que apunta desde el centro del nodo de origen al centro del nodo de destino en X e Y, y luego normalizamos los componentes dividiéndolos por la longitud del vector. Esto nos da un delta de unidades en X e Y que, al multiplicarlo por el radio del nodo (que es 10), nos da el desplazamiento que hay que sumar a un extremo del borde y restar del otro.
Si la longitud del vector es inferior a 20 (es decir, si dos nodos se solapan), fijamos los punteros de origen y destino en el centro del nodo de origen. En la práctica, este caso es muy difícil de reproducir manualmente, ya que las fuerzas entre los dos nodos alcanzan entonces su máximo.
Es importante señalar que en esta función llamamos a ` prepareGeometryChange()`. El motivo es que las variables ` sourcePoint ` y ` destPoint ` se utilizan directamente al dibujar, y son devueltas por la reimplementación de ` boundingRect()`. Siempre debemos llamar a prepareGeometryChange() antes de modificar lo que devuelve boundingRect(), y antes de que estas variables puedan ser utilizadas por paint(), para mantener ordenada la gestión interna de Graphics View. Lo más seguro es llamar a esta función una sola vez, inmediatamente antes de modificar cualquiera de estas variables.
QRectF Edge::boundingRect() const
{
if (!source || !dest)
return QRectF();
qreal penWidth = 1;
qreal extra = (penWidth + arrowSize) / 2.0;
return QRectF(sourcePoint, QSizeF(destPoint.x() - sourcePoint.x(),
destPoint.y() - sourcePoint.y()))
.normalized()
.adjusted(-extra, -extra, extra, extra);
}El rectángulo delimitador del borde se define como el rectángulo más pequeño que incluye tanto el punto inicial como el final del borde. Como dibujamos una flecha en cada borde, también debemos compensar ajustando la mitad del tamaño de la flecha y la mitad del ancho del trazo en todas las direcciones. El trazo se utiliza para dibujar el contorno de la flecha, y podemos suponer que la mitad del contorno se dibuja fuera del área de la flecha y la otra mitad, dentro.
void Edge::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
{
if (!source || !dest)
return;
QLineF line(sourcePoint, destPoint);
if (qFuzzyCompare(line.length(), qreal(0.)))
return;Comenzamos la reimplementación de ` paint()` comprobando algunas condiciones previas. En primer lugar, si el nodo de origen o el de destino no están definidos, retornamos inmediatamente; no hay nada que dibujar.
Al mismo tiempo, comprobamos si la longitud del borde es aproximadamente 0 y, de ser así, también salimos de la función.
// Draw the line itself
painter->setPen(QPen(Qt::black, 1, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
painter->drawLine(line);Dibujamos la línea utilizando un trazo con uniones y extremos redondeados. Si ejecutas el ejemplo, amplías la imagen y examinas el borde con detalle, verás que no hay bordes afilados ni cuadrados.
// Draw the arrows
double angle = std::atan2(-line.dy(), line.dx());
QPointF sourceArrowP1 = sourcePoint + QPointF(sin(angle + M_PI / 3) * arrowSize,
cos(angle + M_PI / 3) * arrowSize);
QPointF sourceArrowP2 = sourcePoint + QPointF(sin(angle + M_PI - M_PI / 3) * arrowSize,
cos(angle + M_PI - M_PI / 3) * arrowSize);
QPointF destArrowP1 = destPoint + QPointF(sin(angle - M_PI / 3) * arrowSize,
cos(angle - M_PI / 3) * arrowSize);
QPointF destArrowP2 = destPoint + QPointF(sin(angle - M_PI + M_PI / 3) * arrowSize,
cos(angle - M_PI + M_PI / 3) * arrowSize);
painter->setBrush(Qt::black);
painter->drawPolygon(QPolygonF() << line.p1() << sourceArrowP1 << sourceArrowP2);
painter->drawPolygon(QPolygonF() << line.p2() << destArrowP1 << destArrowP2);
}A continuación, dibujamos una flecha en cada extremo del borde. Cada flecha se dibuja como un polígono con relleno negro. Las coordenadas de la flecha se determinan mediante trigonometría sencilla.
Definición de la clase GraphWidget
GraphWidget es una subclase de ` QGraphicsView`, que proporciona a la ventana principal barras de desplazamiento.
class GraphWidget : public QGraphicsView
{
Q_OBJECT
public:
GraphWidget(QWidget *parent = nullptr);
void itemMoved();
public slots:
void shuffle();
void zoomIn();
void zoomOut();
protected:
void keyPressEvent(QKeyEvent *event) override;
void timerEvent(QTimerEvent *event) override;
#if QT_CONFIG(wheelevent)
void wheelEvent(QWheelEvent *event) override;
#endif
void drawBackground(QPainter *painter, const QRectF &rect) override;
void scaleView(qreal scaleFactor);
private:
QBasicTimer timer;
Node *centerNode;
};La clase proporciona un constructor básico que inicializa la escena, una función ` itemMoved() ` para notificar cambios en el grafo de nodos de la escena, varios controladores de eventos, una reimplementación de ` drawBackground()` y una función auxiliar para escalar la vista mediante la rueda del ratón o el teclado.
GraphWidget::GraphWidget(QWidget *parent)
: QGraphicsView(parent)
{
QGraphicsScene *scene = new QGraphicsScene(this);
scene->setItemIndexMethod(QGraphicsScene::NoIndex);
scene->setSceneRect(-200, -200, 400, 400);
setScene(scene);
setCacheMode(CacheBackground);
setViewportUpdateMode(BoundingRectViewportUpdate);
setRenderHint(QPainter::Antialiasing);
setTransformationAnchor(AnchorUnderMouse);
scale(qreal(0.8), qreal(0.8));
setMinimumSize(400, 400);
setWindowTitle(tr("Elastic Nodes"));GraphicsWidgetEl constructor de `scene` crea la escena y, dado que la mayoría de los elementos se mueven la mayor parte del tiempo, establece ` QGraphicsScene::NoIndex`. A continuación, la escena obtiene un ` scene rectangle` fijo y se asigna a la vista ` GraphWidget `.
La vista permite que QGraphicsView::CacheBackground almacene en caché el renderizado de su fondo estático y algo complejo. Dado que el gráfico renderiza un conjunto denso de elementos pequeños que se mueven constantemente, no es necesario que Graphics View pierda tiempo buscando regiones de actualización precisas, por lo que establecemos el modo de actualización de la ventana gráfica QGraphicsView::BoundingRectViewportUpdate. El valor predeterminado funcionaría bien, pero este modo es notablemente más rápido para este ejemplo.
Para mejorar la calidad de la representación, establecemos ` QPainter::Antialiasing`.
El anclaje de transformación determina cómo debe desplazarse la vista al transformarla o, en nuestro caso, al acercar o alejar la imagen. Hemos elegido « QGraphicsView::AnchorUnderMouse », que centra la vista en el punto situado bajo el cursor del ratón. Esto facilita el acercamiento a un punto de la escena moviendo el ratón sobre él y, a continuación, girando la rueda del ratón.
Por último, asignamos a la ventana un tamaño mínimo que se ajusta al tamaño predeterminado de la escena y establecemos un título adecuado para la ventana.
Node *node1 = new Node(this);
Node *node2 = new Node(this);
Node *node3 = new Node(this);
Node *node4 = new Node(this);
centerNode = new Node(this);
Node *node6 = new Node(this);
Node *node7 = new Node(this);
Node *node8 = new Node(this);
Node *node9 = new Node(this);
scene->addItem(node1);
scene->addItem(node2);
scene->addItem(node3);
scene->addItem(node4);
scene->addItem(centerNode);
scene->addItem(node6);
scene->addItem(node7);
scene->addItem(node8);
scene->addItem(node9);
scene->addItem(new Edge(node1, node2));
scene->addItem(new Edge(node2, node3));
scene->addItem(new Edge(node2, centerNode));
scene->addItem(new Edge(node3, node6));
scene->addItem(new Edge(node4, node1));
scene->addItem(new Edge(node4, centerNode));
scene->addItem(new Edge(centerNode, node6));
scene->addItem(new Edge(centerNode, node8));
scene->addItem(new Edge(node6, node9));
scene->addItem(new Edge(node7, node4));
scene->addItem(new Edge(node8, node7));
scene->addItem(new Edge(node9, node8));
node1->setPos(-50, -50);
node2->setPos(0, -50);
node3->setPos(50, -50);
node4->setPos(-50, 0);
centerNode->setPos(0, 0);
node6->setPos(50, 0);
node7->setPos(-50, 50);
node8->setPos(0, 50);
node9->setPos(50, 50);
}La última parte del constructor crea la cuadrícula de nodos y aristas, y asigna a cada nodo una posición inicial.
void GraphWidget::itemMoved()
{
using namespace std::chrono_literals;
if (!timer.isActive())
timer.start(1000ms / 25, this);
}GraphWidget Se notifica el movimiento de los nodos a través de esta función itemMoved(). Su función consiste simplemente en reiniciar el temporizador principal en caso de que aún no se esté ejecutando. El temporizador está diseñado para detenerse cuando el gráfico se estabiliza y para reiniciarse en cuanto vuelve a ser inestable.
void GraphWidget::keyPressEvent(QKeyEvent *event)
{
switch (event->key()) {
case Qt::Key_Up:
centerNode->moveBy(0, -20);
break;
case Qt::Key_Down:
centerNode->moveBy(0, 20);
break;
case Qt::Key_Left:
centerNode->moveBy(-20, 0);
break;
case Qt::Key_Right:
centerNode->moveBy(20, 0);
break;
case Qt::Key_Plus:
zoomIn();
break;
case Qt::Key_Minus:
zoomOut();
break;
case Qt::Key_Space:
case Qt::Key_Enter:
shuffle();
break;
default:
QGraphicsView::keyPressEvent(event);
}
}Este es el controlador de eventos de teclas de GraphWidget. Las teclas de flecha mueven el nodo central, las teclas «+» y «-» acercan y alejan la vista llamando a scaleView(), y las teclas Intro y Espacio aleatorizan las posiciones de los nodos. El resto de eventos de teclas (por ejemplo, Av Pág y Re Pág) se gestionan mediante la implementación predeterminada de QGraphicsView.
void GraphWidget::timerEvent(QTimerEvent *event)
{
Q_UNUSED(event);
QList<Node *> nodes;
const QList<QGraphicsItem *> items = scene()->items();
for (QGraphicsItem *item : items) {
if (Node *node = qgraphicsitem_cast<Node *>(item))
nodes << node;
}
for (Node *node : std::as_const(nodes))
node->calculateForces();
bool itemsMoved = false;
for (Node *node : std::as_const(nodes)) {
if (node->advancePosition())
itemsMoved = true;
}
if (!itemsMoved)
timer.stop();
}La función del controlador de eventos del temporizador es ejecutar todo el mecanismo de cálculo de fuerzas como una animación fluida. Cada vez que se activa el temporizador, el controlador localiza todos los nodos de la escena y llama a la función ` Node::calculateForces() ` en cada nodo, uno por uno. A continuación, en un paso final, llamará a ` Node::advance() ` para mover todos los nodos a sus nuevas posiciones. Al comprobar el valor de retorno de ` advance()`, podemos determinar si la cuadrícula se ha estabilizado (es decir, si ningún nodo se ha movido). Si es así, podemos detener el temporizador.
void GraphWidget::wheelEvent(QWheelEvent *event)
{
scaleView(pow(2., -event->angleDelta().y() / 240.0));
}En el controlador de eventos de la rueda del ratón, convertimos el delta de la rueda del ratón en un factor de escala y pasamos este factor a scaleView(). Este enfoque tiene en cuenta la velocidad a la que se gira la rueda. Cuanto más rápido se gire la rueda del ratón, más rápido se ampliará la vista.
void GraphWidget::drawBackground(QPainter *painter, const QRectF &rect)
{
Q_UNUSED(rect);
// Shadow
QRectF sceneRect = this->sceneRect();
QRectF rightShadow(sceneRect.right(), sceneRect.top() + 5, 5, sceneRect.height());
QRectF bottomShadow(sceneRect.left() + 5, sceneRect.bottom(), sceneRect.width(), 5);
if (rightShadow.intersects(rect) || rightShadow.contains(rect))
painter->fillRect(rightShadow, Qt::darkGray);
if (bottomShadow.intersects(rect) || bottomShadow.contains(rect))
painter->fillRect(bottomShadow, Qt::darkGray);
// Fill
QLinearGradient gradient(sceneRect.topLeft(), sceneRect.bottomRight());
gradient.setColorAt(0, Qt::white);
gradient.setColorAt(1, Qt::lightGray);
painter->fillRect(rect.intersected(sceneRect), gradient);
painter->setBrush(Qt::NoBrush);
painter->drawRect(sceneRect);
// Text
QRectF textRect(sceneRect.left() + 4, sceneRect.top() + 4,
sceneRect.width() - 4, sceneRect.height() - 4);
QString message(tr("Click and drag the nodes around, and zoom with the mouse "
"wheel or the '+' and '-' keys"));
QFont font = painter->font();
font.setBold(true);
font.setPointSize(14);
painter->setFont(font);
painter->setPen(Qt::lightGray);
painter->drawText(textRect.translated(2, 2), message);
painter->setPen(Qt::black);
painter->drawText(textRect, message);
}El fondo de la vista se representa en una reimplementación de ` QGraphicsView::drawBackground()`. Dibujamos un rectángulo grande relleno con un degradado lineal, añadimos una sombra paralela y, a continuación, representamos el texto encima. El texto se representa dos veces para conseguir un sencillo efecto de sombra paralela.
Esta representación del fondo consume muchos recursos; por eso la vista habilita la función auxiliar ` QGraphicsView::CacheBackground`.
void GraphWidget::scaleView(qreal scaleFactor)
{
qreal factor = transform().scale(scaleFactor, scaleFactor).mapRect(QRectF(0, 0, 1, 1)).width();
if (factor < 0.07 || factor > 100)
return;
scale(scaleFactor, scaleFactor);
}La función auxiliar scaleView() comprueba que el factor de escala se mantenga dentro de ciertos límites (es decir, no se puede ampliar ni reducir demasiado) y, a continuación, aplica esta escala a la vista.
La función `main()`
En contraste con la complejidad del resto de este ejemplo, la función ` main() ` es muy sencilla: creamos una instancia de ` QApplication ` y, a continuación, creamos y mostramos una instancia de ` GraphWidget`. Dado que todos los nodos de la cuadrícula se mueven inicialmente, el temporizador ` GraphWidget ` se iniciará inmediatamente después de que el control haya vuelto al bucle de eventos.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.