En esta página

Ejemplo de escena de diagrama

Mostrar cómo utilizar el marco de trabajo «Graphics View».

Aplicación con diversos gráficos de diagramas de flujo e iconos

El ejemplo «Diagram Scene» es una aplicación en la que se puede crear un diagrama de flujo. Es posible añadir formas de diagrama de flujo y texto, y conectar las formas mediante flechas, tal y como se muestra en la imagen anterior. A las formas, las flechas y el texto se les pueden asignar diferentes colores, y es posible cambiar la fuente, el estilo y el subrayado del texto.

El marco de trabajo «Graphics View» de Qt está diseñado para gestionar y mostrar elementos gráficos 2D personalizados. Las clases principales del marco de trabajo son « QGraphicsItem », « QGraphicsScene » y « QGraphicsView ». La escena gráfica gestiona los elementos y les proporciona una superficie. « QGraphicsView » es un widget que se utiliza para representar una escena en la pantalla. Consulte el marco de trabajo «Graphics View» para obtener una descripción más detallada del mismo.

En este ejemplo mostramos cómo crear este tipo de escenas gráficas y elementos personalizados mediante la implementación de clases que heredan de QGraphicsScene y QGraphicsItem.

En concreto, mostramos cómo:

  • Crear elementos gráficos personalizados.
  • Gestionar eventos del ratón y el movimiento de los elementos.
  • Implementar una escena gráfica capaz de gestionar nuestros elementos personalizados.
  • Pintar elementos de forma personalizada.
  • Crear un elemento de texto movible y editable.

El ejemplo consta de las siguientes clases:

  • MainWindow crea los widgets y los muestra en un ` QMainWindow`. También gestiona la interacción entre los widgets y la escena gráfica, la vista y los elementos.
  • DiagramItem hereda de ` QGraphicsPolygonItem ` y representa una forma de diagrama de flujo.
  • TextDiagramItem hereda de ` QGraphicsTextItem ` y representa elementos de texto en el diagrama. La clase añade la posibilidad de mover el elemento con el ratón, algo que no admite ` QGraphicsTextItem`.
  • Arrow Heredan de ` QGraphicsLineItem ` y son flechas que conectan dos `DiagramItems`.
  • DiagramScene Heredan de `QGraphicsDiagramScene` y proporcionan soporte para ` DiagramItem`, ` Arrow ` y ` DiagramTextItem ` (además del soporte ya gestionado por ` QGraphicsScene`).

Definición de la clase MainWindow

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
   MainWindow();

private slots:
    void backgroundButtonGroupClicked(QAbstractButton *button);
    void buttonGroupClicked(QAbstractButton *button);
    void deleteItem();
    void pointerGroupClicked();
    void bringToFront();
    void sendToBack();
    void itemInserted(DiagramItem *item);
    void textInserted(QGraphicsTextItem *item);
    void currentFontChanged(const QFont &font);
    void fontSizeChanged(const QString &size);
    void sceneScaleChanged(const QString &scale);
    void textColorChanged();
    void itemColorChanged();
    void lineColorChanged();
    void textButtonTriggered();
    void fillButtonTriggered();
    void lineButtonTriggered();
    void handleFontChange();
    void itemSelected(QGraphicsItem *item);
    void about();

private:
    void createToolBox();
    void createActions();
    void createMenus();
    void createToolbars();
    QWidget *createBackgroundCellWidget(const QString &text,
                                        const QString &image);
    QWidget *createCellWidget(const QString &text,
                              DiagramItem::DiagramType type);

    template<typename PointerToMemberFunction>
    QMenu *createColorMenu(const PointerToMemberFunction &slot, QColor defaultColor);
    QIcon createColorToolButtonIcon(const QString &image, QColor color);
    QIcon createColorIcon(QColor color);

    DiagramScene *scene;
    QGraphicsView *view;

    QAction *exitAction;
    QAction *addAction;
    QAction *deleteAction;

    QAction *toFrontAction;
    QAction *sendBackAction;
    QAction *aboutAction;

    QMenu *fileMenu;
    QMenu *itemMenu;
    QMenu *aboutMenu;

    QToolBar *textToolBar;
    QToolBar *editToolBar;
    QToolBar *colorToolBar;
    QToolBar *pointerToolbar;

    QComboBox *sceneScaleCombo;
    QComboBox *itemColorCombo;
    QComboBox *textColorCombo;
    QComboBox *fontSizeCombo;
    QFontComboBox *fontCombo;

    QToolBox *toolBox;
    QButtonGroup *buttonGroup;
    QButtonGroup *pointerTypeGroup;
    QButtonGroup *backgroundButtonGroup;
    QToolButton *fontColorToolButton;
    QToolButton *fillColorToolButton;
    QToolButton *lineColorToolButton;
    QAction *boldAction;
    QAction *underlineAction;
    QAction *italicAction;
    QAction *textAction;
    QAction *fillAction;
    QAction *lineAction;
};

La clase « MainWindow » crea y distribuye los widgets en una « QMainWindow ». La clase reenvía las entradas de los widgets a «DiagramScene». También actualiza sus widgets cuando cambia el elemento de texto de la escena del diagrama, o cuando se inserta en la escena un elemento del diagrama o un elemento de texto del diagrama.

La clase también elimina elementos de la escena y gestiona el orden Z, que determina el orden en el que se dibujan los elementos cuando se superponen entre sí.

Implementación de la clase MainWindow

Empezamos echando un vistazo al constructor:

MainWindow::MainWindow()
{
    createActions();
    createToolBox();
    createMenus();

    scene = new DiagramScene(itemMenu, this);
    scene->setSceneRect(QRectF(0, 0, 5000, 5000));
    connect(scene, &DiagramScene::itemInserted,
            this, &MainWindow::itemInserted);
    connect(scene, &DiagramScene::textInserted,
            this, &MainWindow::textInserted);
    connect(scene, &DiagramScene::itemSelected,
            this, &MainWindow::itemSelected);
    createToolbars();

    QHBoxLayout *layout = new QHBoxLayout;
    layout->addWidget(toolBox);
    view = new QGraphicsView(scene);
    layout->addWidget(view);

    QWidget *widget = new QWidget;
    widget->setLayout(layout);

    setCentralWidget(widget);
    setWindowTitle(tr("Diagramscene"));
    setUnifiedTitleAndToolBarOnMac(true);
}

En el constructor llamamos a métodos para crear los widgets y los diseños del ejemplo antes de crear la escena del diagrama. Las barras de herramientas deben crearse después de la escena, ya que se conectan a sus señales. A continuación, distribuimos los widgets en la ventana.

Nos conectamos a las ranuras « itemInserted() » y « textInserted() » de la escena del diagrama, ya que queremos desmarcar los botones de la caja de herramientas cuando se inserta un elemento. Cuando se selecciona un elemento en la escena, recibimos la señal « itemSelected() ». Utilizamos esto para actualizar los widgets que muestran las propiedades de la fuente si el elemento seleccionado es un « DiagramTextItem ».

La función createToolBox() crea y distribuye los widgets de toolBox QToolBox . No la analizaremos con gran detalle, ya que no se ocupa de funcionalidades específicas del marco gráfico. Aquí está su implementación:

void MainWindow::createToolBox()
{
    buttonGroup = new QButtonGroup(this);
    buttonGroup->setExclusive(false);
    connect(buttonGroup, QOverload<QAbstractButton *>::of(&QButtonGroup::buttonClicked),
            this, &MainWindow::buttonGroupClicked);
    QGridLayout *layout = new QGridLayout;
    layout->addWidget(createCellWidget(tr("Conditional"), DiagramItem::Conditional), 0, 0);
    layout->addWidget(createCellWidget(tr("Process"), DiagramItem::Step),0, 1);
    layout->addWidget(createCellWidget(tr("Input/Output"), DiagramItem::Io), 1, 0);

Esta parte de la función configura el elemento de widget con pestañas que contiene las formas del diagrama de flujo. Un QButtonGroup exclusivo siempre mantiene un botón marcado; queremos que el grupo permita que todos los botones estén desmarcados. Seguimos utilizando un grupo de botones, ya que podemos asociar datos de usuario —que utilizamos para almacenar el tipo de diagrama— a cada botón. La función createCellWidget() configura los botones del elemento de widget con pestañas y se analiza más adelante.

Los botones del elemento de widget con pestañas de fondo se configuran de la misma manera, así que pasamos a la creación de la caja de herramientas:

    toolBox = new QToolBox;
    toolBox->setSizePolicy(QSizePolicy(QSizePolicy::Maximum, QSizePolicy::Ignored));
    toolBox->setMinimumWidth(itemWidget->sizeHint().width());
    toolBox->addItem(itemWidget, tr("Basic Flowchart Shapes"));
    toolBox->addItem(backgroundWidget, tr("Backgrounds"));
}

Establecemos el tamaño preferido de la caja de herramientas como su tamaño máximo. De esta forma, se destina más espacio a la vista gráfica.

Aquí está la función « createActions() »:

void MainWindow::createActions()
{
    toFrontAction = new QAction(QIcon(":/images/bringtofront.png"),
                                tr("Bring to &Front"), this);
    toFrontAction->setShortcut(tr("Ctrl+F"));
    toFrontAction->setStatusTip(tr("Bring item to front"));
    connect(toFrontAction, &QAction::triggered, this, &MainWindow::bringToFront);

Mostramos un ejemplo de la creación de una acción. La funcionalidad que desencadenan las acciones se analiza en las ranuras a las que conectamos las acciones.

Esta es la función ` createMenus() `:

void MainWindow::createMenus()
{
    fileMenu = menuBar()->addMenu(tr("&File"));
    fileMenu->addAction(exitAction);

    itemMenu = menuBar()->addMenu(tr("&Item"));
    itemMenu->addAction(deleteAction);
    itemMenu->addSeparator();
    itemMenu->addAction(toFrontAction);
    itemMenu->addAction(sendBackAction);

    aboutMenu = menuBar()->addMenu(tr("&Help"));
    aboutMenu->addAction(aboutAction);
}

Creamos los tres menús del ejemplo.

La función ` createToolbars() ` configura las barras de herramientas de los ejemplos. Las tres ` QToolButton` en ` colorToolBar`, ` fontColorToolButton`, ` fillColorToolButton` y ` lineColorToolButton` son interesantes, ya que creamos iconos para ellas dibujando en un ` QPixmap ` con un ` QPainter`. Mostramos cómo se crea el ` fillColorToolButton `. Este botón permite al usuario seleccionar un color para los elementos del diagrama.

void MainWindow::createToolbars()
{
    ...
    fillColorToolButton = new QToolButton;
    fillColorToolButton->setPopupMode(QToolButton::MenuButtonPopup);
    fillColorToolButton->setMenu(createColorMenu(&MainWindow::itemColorChanged, Qt::white));
    fillAction = fillColorToolButton->menu()->defaultAction();
    fillColorToolButton->setIcon(createColorToolButtonIcon(
                                     ":/images/floodfill.png", Qt::white));
    connect(fillColorToolButton, &QAbstractButton::clicked,
            this, &MainWindow::fillButtonTriggered);

Configuramos el menú del botón de la herramienta con setMenu(). Necesitamos que el objeto fillAction QAction apunte siempre a la acción seleccionada del menú. El menú se crea con la función createColorMenu() y, como veremos más adelante, contiene un elemento de menú para cada color que pueden tener los elementos. Cuando el usuario pulsa el botón, lo que activa la señal clicked(), podemos establecer el color del elemento seleccionado en el color de fillAction. Es con createColorToolButtonIcon() como creamos el icono del botón.

    ...
}

A continuación se muestra la función createBackgroundCellWidget():

QWidget *MainWindow::createBackgroundCellWidget(const QString &text, const QString &image)
{
    QToolButton *button = new QToolButton;
    button->setText(text);
    button->setIcon(QIcon(image));
    button->setIconSize(QSize(50, 50));
    button->setCheckable(true);
    backgroundButtonGroup->addButton(button);

    QGridLayout *layout = new QGridLayout;
    layout->addWidget(button, 0, 0, Qt::AlignHCenter);
    layout->addWidget(new QLabel(text), 1, 0, Qt::AlignCenter);

    QWidget *widget = new QWidget;
    widget->setLayout(layout);

    return widget;
}

Esta función crea QWidgetque contienen un botón de herramienta y una etiqueta. Los widgets creados con esta función se utilizan para el elemento de fondo del widget con pestañas de la caja de herramientas.

A continuación se muestra la función ` createCellWidget() `:

QWidget *MainWindow::createCellWidget(const QString &text, DiagramItem::DiagramType type)
{

    DiagramItem item(type, itemMenu);
    QIcon icon(item.image());

    QToolButton *button = new QToolButton;
    button->setIcon(icon);
    button->setIconSize(QSize(50, 50));
    button->setCheckable(true);
    buttonGroup->addButton(button, int(type));

    QGridLayout *layout = new QGridLayout;
    layout->addWidget(button, 0, 0, Qt::AlignHCenter);
    layout->addWidget(new QLabel(text), 1, 0, Qt::AlignCenter);

    QWidget *widget = new QWidget;
    widget->setLayout(layout);

    return widget;
}

Esta función devuelve un objeto ` QWidget ` que contiene un ` QToolButton ` con una imagen de una de las formas de diagrama de flujo ( DiagramItems). La imagen se crea mediante el ` DiagramItem ` a través de la función ` image() `. La clase QButtonGroup nos permite asignar un identificador (int) a cada botón; almacenamos el tipo de diagrama, es decir, la enumeración DiagramItem::DiagramType. Utilizamos el tipo de diagrama almacenado cuando creamos nuevos elementos de diagrama para la escena. Los widgets creados con esta función se utilizan en la caja de herramientas.

Esta es la función ` createColorMenu() `:

template<typename PointerToMemberFunction>
QMenu *MainWindow::createColorMenu(const PointerToMemberFunction &slot, QColor defaultColor)
{
    QList<QColor> colors;
    colors << Qt::black << Qt::white << Qt::red << Qt::blue << Qt::yellow;
    QStringList names;
    names << tr("black") << tr("white") << tr("red") << tr("blue")
          << tr("yellow");

    QMenu *colorMenu = new QMenu(this);
    for (int i = 0; i < colors.count(); ++i) {
        QAction *action = new QAction(names.at(i), this);
        action->setData(colors.at(i));
        action->setIcon(createColorIcon(colors.at(i)));
        connect(action, &QAction::triggered, this, slot);
        colorMenu->addAction(action);
        if (colors.at(i) == defaultColor)
            colorMenu->setDefaultAction(action);
    }
    return colorMenu;
}

Esta función crea un menú de colores que se utiliza como menú desplegable para los botones de herramientas de la caja de herramientas ( colorToolBar). Creamos una acción para cada color que añadimos al menú. Recuperamos los datos de las acciones cuando establecemos el color de los elementos, las líneas y el texto.

Esta es la función « createColorToolButtonIcon() »:

QIcon MainWindow::createColorToolButtonIcon(const QString &imageFile, QColor color)
{
    QPixmap pixmap(50, 80);
    pixmap.fill(Qt::transparent);
    QPainter painter(&pixmap);
    QPixmap image(imageFile);
    // Draw icon centred horizontally on button.
    QRect target(4, 0, 42, 43);
    QRect source(0, 0, 42, 43);
    painter.fillRect(QRect(0, 60, 50, 80), color);
    painter.drawPixmap(target, image, source);

    return QIcon(pixmap);
}

Esta función se utiliza para crear el « QIcon » de « fillColorToolButton », « fontColorToolButton » y « lineColorToolButton ». La cadena « imageFile » es el texto, el relleno o el símbolo de línea que se utiliza para los botones. Debajo de la imagen dibujamos un rectángulo relleno utilizando « color ».

Aquí está la función createColorIcon():

QIcon MainWindow::createColorIcon(QColor color)
{
    QPixmap pixmap(20, 20);
    QPainter painter(&pixmap);
    painter.setPen(Qt::NoPen);
    painter.fillRect(QRect(0, 0, 20, 20), color);

    return QIcon(pixmap);
}

Esta función crea un icono con un rectángulo relleno del color de ` color`. Se utiliza para crear iconos para los menús de colores en ` fillColorToolButton`, ` fontColorToolButton` y ` lineColorToolButton`.

Aquí está la ranura « backgroundButtonGroupClicked() »:

void MainWindow::backgroundButtonGroupClicked(QAbstractButton *button)
{
    const QList<QAbstractButton *> buttons = backgroundButtonGroup->buttons();
    for (QAbstractButton *myButton : buttons) {
        if (myButton != button)
            button->setChecked(false);
    }
    QString text = button->text();
    if (text == tr("Blue Grid"))
        scene->setBackgroundBrush(QPixmap(":/images/background1.png"));
    else if (text == tr("White Grid"))
        scene->setBackgroundBrush(QPixmap(":/images/background2.png"));
    else if (text == tr("Gray Grid"))
        scene->setBackgroundBrush(QPixmap(":/images/background3.png"));
    else
        scene->setBackgroundBrush(QPixmap(":/images/background4.png"));

    scene->update();
    view->update();
}

En esta función configuramos el « QBrush », que se utiliza para dibujar el fondo de la escena del diagrama. El fondo puede ser una cuadrícula de casillas azules, grises o blancas, o bien no tener cuadrícula alguna. Disponemos de « QPixmap» de las casillas a partir de archivos PNG con los que creamos el pincel.

Cuando se pulsa uno de los botones del elemento de widget con pestañas del fondo, cambiamos el pincel; averiguamos qué botón es comprobando su texto.

A continuación se muestra la implementación de « buttonGroupClicked() »:

void MainWindow::buttonGroupClicked(QAbstractButton *button)
{
    const QList<QAbstractButton *> buttons = buttonGroup->buttons();
    for (QAbstractButton *myButton : buttons) {
        if (myButton != button)
            button->setChecked(false);
    }
    const int id = buttonGroup->id(button);
    if (id == InsertTextButton) {
        scene->setMode(DiagramScene::InsertText);
    } else {
        scene->setItemType(DiagramItem::DiagramType(id));
        scene->setMode(DiagramScene::InsertItem);
    }
}

Esta ranura se activa cuando se marca un botón en buttonGroup. Al marcar un botón, el usuario puede hacer clic en la vista gráfica y se insertará un DiagramItem del tipo seleccionado en DiagramScene. Debemos recorrer los botones del grupo para desmarcar los demás, ya que solo se permite marcar un botón a la vez.

QButtonGroup Asigna un identificador a cada botón. Hemos establecido el identificador de cada botón como el tipo de diagrama, tal y como lo proporciona DiagramItem::DiagramType, que se insertará en la escena al hacer clic en él. A continuación, podemos utilizar el identificador del botón al establecer el tipo de diagrama con ` setItemType()`. En el caso del texto, hemos asignado un identificador cuyo valor no figura en la enumeración `DiagramType`.

A continuación se muestra la implementación de ` deleteItem()`:

void MainWindow::deleteItem()
{
    QList<QGraphicsItem *> selectedItems = scene->selectedItems();
    for (QGraphicsItem *item : std::as_const(selectedItems)) {
        if (item->type() == Arrow::Type) {
            scene->removeItem(item);
            Arrow *arrow = qgraphicsitem_cast<Arrow *>(item);
            arrow->startItem()->removeArrow(arrow);
            arrow->endItem()->removeArrow(arrow);
            delete item;
        }
    }

    selectedItems = scene->selectedItems();
    for (QGraphicsItem *item : std::as_const(selectedItems)) {
         if (item->type() == DiagramItem::Type)
             qgraphicsitem_cast<DiagramItem *>(item)->removeArrows();
         scene->removeItem(item);
         delete item;
     }
}

Esta ranura elimina el elemento seleccionado, si lo hay, de la escena. Elimina primero las flechas para evitar eliminarlas dos veces. Si el elemento que se va a eliminar es un ` DiagramItem`, también debemos eliminar las flechas conectadas a él; no queremos que haya flechas en la escena que no estén conectadas a elementos en ambos extremos.

Esta es la implementación de `pointerGroupClicked()`:

void MainWindow::pointerGroupClicked()
{
    scene->setMode(DiagramScene::Mode(pointerTypeGroup->checkedId()));
}

El « pointerTypeGroup » determina si la escena se encuentra en modo «ItemMove» o «InsertLine». Este grupo de botones es exclusivo, es decir, solo puede estar marcado un botón a la vez. Al igual que con el « buttonGroup » anterior, hemos asignado a los botones un identificador que coincide con los valores de la enumeración DiagramScene::Mode, de modo que podamos utilizar dicho identificador para establecer el modo correcto.

Aquí está la ranura « bringToFront() »:

void MainWindow::bringToFront()
{
    if (scene->selectedItems().isEmpty())
        return;

    QGraphicsItem *selectedItem = scene->selectedItems().first();
    const QList<QGraphicsItem *> overlapItems = selectedItem->collidingItems();

    qreal zValue = 0;
    for (const QGraphicsItem *item : overlapItems) {
        if (item->zValue() >= zValue && item->type() == DiagramItem::Type)
            zValue = item->zValue() + 0.1;
    }
    selectedItem->setZValue(zValue);
}

Varios elementos pueden colisionar, es decir, solaparse, entre sí en la escena. Esta ranura se activa cuando el usuario solicita que un elemento se coloque encima de los elementos con los que colisiona. Los elementos « QGrapicsItems » tienen un valor z que determina el orden en el que se apilan los elementos en la escena; puedes imaginártelo como el eje z en un sistema de coordenadas 3D. Cuando los elementos colisionan, aquellos con valores z más altos se dibujarán encima de los que tengan valores más bajos. Cuando traemos un elemento al primer plano, podemos recorrer los elementos con los que colisiona y establecer un valor z que sea mayor que todos ellos.

Aquí está la ranura « sendToBack() »:

void MainWindow::sendToBack()
{
    if (scene->selectedItems().isEmpty())
        return;

    QGraphicsItem *selectedItem = scene->selectedItems().first();
    const QList<QGraphicsItem *> overlapItems = selectedItem->collidingItems();

    qreal zValue = 0;
    for (const QGraphicsItem *item : overlapItems) {
        if (item->zValue() <= zValue && item->type() == DiagramItem::Type)
            zValue = item->zValue() - 0.1;
    }
    selectedItem->setZValue(zValue);
}

Esta ranura funciona de la misma manera que « bringToFront() », descrita anteriormente, pero establece un valor z inferior al de los elementos con los que choca el elemento que debe enviarse al fondo.

Esta es la implementación de « itemInserted() »:

void MainWindow::itemInserted(DiagramItem *item)
{
    pointerTypeGroup->button(int(DiagramScene::MoveItem))->setChecked(true);
    scene->setMode(DiagramScene::Mode(pointerTypeGroup->checkedId()));
    buttonGroup->button(int(item->diagramType()))->setChecked(false);
}

Esta ranura se invoca desde « DiagramScene » cuando se ha añadido un elemento a la escena. Restablecemos el modo de la escena al que tenía antes de insertar el elemento, que es «ItemMove» o «InsertText», dependiendo del botón que esté marcado en « pointerTypeGroup ». También debemos desmarcar el botón en « buttonGroup ».

A continuación se muestra la implementación de « textInserted() »:

void MainWindow::textInserted(QGraphicsTextItem *)
{
    buttonGroup->button(InsertTextButton)->setChecked(false);
    scene->setMode(DiagramScene::Mode(pointerTypeGroup->checkedId()));
}

Simplemente restablecemos el modo de la escena al que tenía antes de que se insertara el texto.

Aquí está la ranura « currentFontChanged() »:

void MainWindow::currentFontChanged(const QFont &)
{
    handleFontChange();
}

Cuando el usuario solicita un cambio de fuente, utilizando uno de los widgets de « fontToolBar », creamos un nuevo objeto « QFont » y configuramos sus propiedades para que coincidan con el estado de los widgets. Esto se realiza en « handleFontChange() », por lo que simplemente llamamos a esa ranura.

Este es el slot « fontSizeChanged() »:

void MainWindow::fontSizeChanged(const QString &)
{
    handleFontChange();
}

Cuando el usuario solicita un cambio de fuente, mediante uno de los widgets de « fontToolBar », creamos un nuevo objeto « QFont » y configuramos sus propiedades para que coincidan con el estado de los widgets. Esto se lleva a cabo en « handleFontChange() », por lo que simplemente llamamos a ese slot.

A continuación se muestra la implementación de ` sceneScaleChanged()`:

void MainWindow::sceneScaleChanged(const QString &scale)
{
    double newScale = scale.left(scale.indexOf(tr("%"))).toDouble() / 100.0;
    QTransform oldMatrix = view->transform();
    view->resetTransform();
    view->translate(oldMatrix.dx(), oldMatrix.dy());
    view->scale(newScale, newScale);
}

El usuario puede aumentar o reducir la escala; con el sceneScaleCombo, se dibuja la escena. No es la escena en sí la que cambia de escala, sino únicamente la vista.

Aquí está la ranura « textColorChanged() »:

void MainWindow::textColorChanged()
{
    textAction = qobject_cast<QAction *>(sender());
    fontColorToolButton->setIcon(createColorToolButtonIcon(
                                     ":/images/textpointer.png",
                                     qvariant_cast<QColor>(textAction->data())));
    textButtonTriggered();
}

Este slot se invoca cuando se pulsa un elemento del menú desplegable de « fontColorToolButton ». Tenemos que cambiar el icono del botón al color de la acción seleccionada en « QAction ». Guardamos un puntero a la acción seleccionada en « textAction ». Es en « textButtonTriggered() » donde cambiamos el color del texto al color de « textAction », por lo que invocamos ese slot.

A continuación se muestra la implementación de « itemColorChanged() »:

void MainWindow::itemColorChanged()
{
    fillAction = qobject_cast<QAction *>(sender());
    fillColorToolButton->setIcon(createColorToolButtonIcon(
                                     ":/images/floodfill.png",
                                     qvariant_cast<QColor>(fillAction->data())));
    fillButtonTriggered();
}

Esta ranura gestiona las solicitudes para cambiar el color de DiagramItems de la misma manera que lo hace textColorChanged() para DiagramTextItems.

Aquí está la implementación de lineColorChanged():

void MainWindow::lineColorChanged()
{
    lineAction = qobject_cast<QAction *>(sender());
    lineColorToolButton->setIcon(createColorToolButtonIcon(
                                     ":/images/linecolor.png",
                                     qvariant_cast<QColor>(lineAction->data())));
    lineButtonTriggered();
}

Esta ranura gestiona las solicitudes para cambiar el color de Arrows de la misma manera que lo hace textColorChanged() para DiagramTextItems.

Aquí está la ranura « textButtonTriggered() »:

void MainWindow::textButtonTriggered()
{
    scene->setTextColor(qvariant_cast<QColor>(textAction->data()));
}

textAction apunta a la opción « QAction » del elemento de menú seleccionado actualmente en el menú desplegable de colores de fontColorToolButton. Hemos establecido los datos de la acción en la opción QColor que representa la acción, por lo que podemos recuperarla fácilmente cuando configuramos el color del texto con setTextColor().

Aquí está la ranura « fillButtonTriggered() »:

void MainWindow::fillButtonTriggered()
{
    scene->setItemColor(qvariant_cast<QColor>(fillAction->data()));
}

fillAction apunta al elemento seleccionado en el menú desplegable de « fillColorToolButton() ». Por lo tanto, podemos utilizar los datos de esta acción cuando establecemos el color del elemento con « setItemColor() ».

Aquí está la ranura « lineButtonTriggered() »:

void MainWindow::lineButtonTriggered()
{
    scene->setLineColor(qvariant_cast<QColor>(lineAction->data()));
}

lineAction apunta al elemento seleccionado en el menú desplegable de lineColorToolButton. Utilizamos sus datos cuando establecemos el color de la flecha con setLineColor().

Esta es la función « handleFontChange() »:

void MainWindow::handleFontChange()
{
    QFont font = fontCombo->currentFont();
    font.setPointSize(fontSizeCombo->currentText().toInt());
    font.setWeight(boldAction->isChecked() ? QFont::Bold : QFont::Normal);
    font.setItalic(italicAction->isChecked());
    font.setUnderline(underlineAction->isChecked());

    scene->setFont(font);
}

handleFontChange() se invoca cuando cambia cualquiera de los widgets que muestran propiedades de fuente. Creamos un nuevo objeto ` QFont ` y configuramos sus propiedades en función de los widgets. A continuación, invocamos la función ` setFont() ` de ` DiagramScene`; es la escena la que establece la fuente de los ` DiagramTextItems ` que gestiona.

Este es el slot de itemSelected():

void MainWindow::itemSelected(QGraphicsItem *item)
{
    DiagramTextItem *textItem =
    qgraphicsitem_cast<DiagramTextItem *>(item);

    QFont font = textItem->font();
    fontCombo->setCurrentFont(font);
    fontSizeCombo->setEditText(QString().setNum(font.pointSize()));
    boldAction->setChecked(font.weight() == QFont::Bold);
    italicAction->setChecked(font.italic());
    underlineAction->setChecked(font.underline());
}

Esta ranura se activa cuando se selecciona un elemento del DiagramScene. En el caso de este ejemplo, solo los elementos de texto emiten señales al ser seleccionados, por lo que no es necesario comprobar qué tipo de gráfico es item.

Configuramos el estado de los widgets para que coincida con las propiedades de la fuente del elemento de texto seleccionado.

Esta es la ranura « about() »:

void MainWindow::about()
{
    QMessageBox::about(this, tr("About Diagram Scene"),
                       tr("The <b>Diagram Scene</b> example shows "
                          "use of the graphics framework."));
}

Esta ranura muestra un cuadro de información sobre el ejemplo cuando el usuario selecciona la opción «Acerca de» del menú de ayuda.

Definición de la clase DiagramScene

La clase « DiagramScene » hereda de « QGraphicsScene » y añade funcionalidad para gestionar « DiagramItems », « Arrows » y « DiagramTextItems », además de los elementos gestionados por su clase superior.

class DiagramScene : public QGraphicsScene
{
    Q_OBJECT

public:
    enum Mode { InsertItem, InsertLine, InsertText, MoveItem };

    explicit DiagramScene(QMenu *itemMenu, QObject *parent = nullptr);
    QFont font() const { return myFont; }
    QColor textColor() const { return myTextColor; }
    QColor itemColor() const { return myItemColor; }
    QColor lineColor() const { return myLineColor; }
    void setLineColor(const QColor &color);
    void setTextColor(const QColor &color);
    void setItemColor(const QColor &color);
    void setFont(const QFont &font);

public slots:
    void setMode(Mode mode);
    void setItemType(DiagramItem::DiagramType type);
    void editorLostFocus(DiagramTextItem *item);

signals:
    void itemInserted(DiagramItem *item);
    void textInserted(QGraphicsTextItem *item);
    void itemSelected(QGraphicsItem *item);

protected:
    void mousePressEvent(QGraphicsSceneMouseEvent *mouseEvent) override;
    void mouseMoveEvent(QGraphicsSceneMouseEvent *mouseEvent) override;
    void mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent) override;

private:
    bool isItemChange(int type) const;

    DiagramItem::DiagramType myItemType;
    QMenu *myItemMenu;
    Mode myMode;
    bool leftButtonDown;
    QPointF startPoint;
    QGraphicsLineItem *line;
    QFont myFont;
    DiagramTextItem *textItem;
    QColor myTextColor;
    QColor myItemColor;
    QColor myLineColor;
};

En la clase ` DiagramScene `, un clic del ratón puede dar lugar a tres acciones diferentes: se puede mover el elemento situado bajo el cursor, se puede insertar un elemento o se puede conectar una flecha entre dos elementos del diagrama. La acción que realiza un clic del ratón depende del modo —definido por la enumeración `Mode`— en el que se encuentre la escena. El modo se establece mediante la función ` setMode() `.

La escena también establece el color de sus elementos y la fuente de sus elementos de texto. Los colores y la fuente utilizados por la escena se pueden configurar mediante las funciones ` setLineColor()`, ` setTextColor()`, ` setItemColor() ` y ` setFont() `. El tipo de ` DiagramItem`, determinado por la función `DiagramItem::DiagramType`, que se creará al insertar un elemento, se establece mediante la ranura ` setItemType() `.

Las clases ` MainWindow ` y ` DiagramScene ` comparten la responsabilidad de la funcionalidad de los ejemplos. ` MainWindow ` se encarga de las siguientes tareas: la eliminación de elementos, texto y flechas; el desplazamiento de elementos del diagrama hacia atrás y hacia delante; y el ajuste de la escala de la escena.

Implementación de la clase DiagramScene

Empezamos por el constructor:

DiagramScene::DiagramScene(QMenu *itemMenu, QObject *parent)
    : QGraphicsScene(parent)
{
    myItemMenu = itemMenu;
    myMode = MoveItem;
    myItemType = DiagramItem::Step;
    line = nullptr;
    textItem = nullptr;
    myItemColor = Qt::white;
    myTextColor = Qt::black;
    myLineColor = Qt::black;
}

La escena utiliza myItemMenu para configurar el menú contextual al crear DiagramItems. Establecemos el modo predeterminado en DiagramScene::MoveItem, ya que esto proporciona el comportamiento predeterminado de QGraphicsScene.

Aquí está la función ` setLineColor() `:

void DiagramScene::setLineColor(const QColor &color)
{
    myLineColor = color;
    if (isItemChange(Arrow::Type)) {
        Arrow *item = qgraphicsitem_cast<Arrow *>(selectedItems().first());
        item->setColor(myLineColor);
        update();
    }
}

La función ` isItemChange ` devuelve `true` si se selecciona un elemento ` Arrow ` en la escena; en ese caso, queremos cambiar su color. Cuando el ` DiagramScene ` crea y añade nuevas flechas a la escena, también utilizará el nuevo ` color`.

Esta es la función setTextColor():

void DiagramScene::setTextColor(const QColor &color)
{
    myTextColor = color;
    if (isItemChange(DiagramTextItem::Type)) {
        DiagramTextItem *item = qgraphicsitem_cast<DiagramTextItem *>(selectedItems().first());
        item->setDefaultTextColor(myTextColor);
    }
}

Esta función establece el color de « DiagramTextItems » de la misma forma que « setLineColor() » establece el color de « Arrows ».

Esta es la función « setItemColor() »:

void DiagramScene::setItemColor(const QColor &color)
{
    myItemColor = color;
    if (isItemChange(DiagramItem::Type)) {
        DiagramItem *item = qgraphicsitem_cast<DiagramItem *>(selectedItems().first());
        item->setBrush(myItemColor);
    }
}

Esta función establece el color que utilizará la escena al crear DiagramItems. También cambia el color de un DiagramItem seleccionado.

Esta es la implementación de ` setFont()`:

void DiagramScene::setFont(const QFont &font)
{
    myFont = font;

    if (isItemChange(DiagramTextItem::Type)) {
        QGraphicsTextItem *item = qgraphicsitem_cast<DiagramTextItem *>(selectedItems().first());
        //At this point the selection can change so the first selected item might not be a DiagramTextItem
        if (item)
            item->setFont(myFont);
    }
}

Establece la fuente que se utilizará para los elementos nuevos y seleccionados; si hay un elemento de texto seleccionado, se aplica « DiagramTextItems ».

Esta es la implementación de la ranura « editorLostFocus() »:

void DiagramScene::editorLostFocus(DiagramTextItem *item)
{
    QTextCursor cursor = item->textCursor();
    cursor.clearSelection();
    item->setTextCursor(cursor);

    if (item->toPlainText().isEmpty()) {
        removeItem(item);
        item->deleteLater();
    }
}

DiagramTextItems emitir una señal cuando pierden el foco, que está conectada a esta ranura. Eliminamos el elemento si no tiene texto. De lo contrario, se produciría una fuga de memoria y se confundiría al usuario, ya que los elementos se editarían al pulsar sobre ellos con el ratón.

La función ` mousePressEvent() ` gestiona los eventos de pulsación del ratón de forma diferente según el modo en el que se encuentre el ` DiagramScene `. Analizamos su implementación para cada modo:

void DiagramScene::mousePressEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
    if (mouseEvent->button() != Qt::LeftButton)
        return;

    DiagramItem *item;
    switch (myMode) {
        case InsertItem:
            item = new DiagramItem(myItemType, myItemMenu);
            item->setBrush(myItemColor);
            addItem(item);
            item->setPos(mouseEvent->scenePos());
            emit itemInserted(item);
            break;

Simplemente creamos un nuevo « DiagramItem » y lo añadimos a la escena en la posición en la que se pulsó el ratón. Ten en cuenta que el origen de su sistema de coordenadas local estará debajo de la posición del puntero del ratón.

        case InsertLine:
            line = new QGraphicsLineItem(QLineF(mouseEvent->scenePos(),
                                        mouseEvent->scenePos()));
            line->setPen(QPen(myLineColor, 2));
            addItem(line);
            break;

El usuario añade un « Arrows » a la escena trazando una línea entre los elementos que la flecha debe conectar. El inicio de la línea queda fijado en el lugar donde el usuario ha hecho clic con el ratón y el final sigue al puntero del ratón mientras se mantenga pulsado el botón. Cuando el usuario suelta el botón del ratón, se añadirá un « Arrow » a la escena si hay un « DiagramItem » debajo del inicio y el final de la línea. Más adelante veremos cómo se implementa esto; aquí simplemente añadimos la línea.

        case InsertText:
            textItem = new DiagramTextItem();
            textItem->setFont(myFont);
            textItem->setTextInteractionFlags(Qt::TextEditorInteraction);
            textItem->setZValue(1000.0);
            connect(textItem, &DiagramTextItem::lostFocus,
                    this, &DiagramScene::editorLostFocus);
            connect(textItem, &DiagramTextItem::selectedChange,
                    this, &DiagramScene::itemSelected);
            addItem(textItem);
            textItem->setDefaultTextColor(myTextColor);
            textItem->setPos(mouseEvent->scenePos());
            emit textInserted(textItem);

El DiagramTextItem es editable cuando está activado el indicador Qt::TextEditorInteraction; de lo contrario, se puede mover con el ratón. Siempre queremos que el texto se dibuje encima de los demás elementos de la escena, por lo que establecemos el valor en un número mayor que el de los demás elementos de la escena.

    default:
        ;
    }
    QGraphicsScene::mousePressEvent(mouseEvent);
}

Estamos en el modo «MoveItem» si llegamos al conmutador por defecto; entonces podemos llamar a la implementación de « QGraphicsScene », que se encarga del movimiento de los elementos con el ratón. Realizamos esta llamada incluso si nos encontramos en otro modo, lo que permite añadir un elemento y, a continuación, mantener pulsado el botón del ratón y empezar a moverlo. En el caso de los elementos de texto, esto no es posible, ya que no propagan eventos del ratón cuando son editables.

Esta es la función ` mouseMoveEvent() `:

void DiagramScene::mouseMoveEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
    if (myMode == InsertLine && line != nullptr) {
        QLineF newLine(line->line().p1(), mouseEvent->scenePos());
        line->setLine(newLine);
    } else if (myMode == MoveItem) {
        QGraphicsScene::mouseMoveEvent(mouseEvent);
    }
}

Debemos trazar la línea si estamos en modo InsertMode y el botón del ratón está pulsado (la línea no es 0). Tal y como se explica en mousePressEvent(), la línea se traza desde la posición en la que se pulsó el ratón hasta la posición actual del ratón.

Si estamos en el modo «MoveItem», llamamos a la implementación de « QGraphicsScene », que se encarga del movimiento de los elementos.

En la función ` mouseReleaseEvent() ` tenemos que comprobar si hay que añadir una flecha a la escena:

void DiagramScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
    if (line != nullptr && myMode == InsertLine) {
        QList<QGraphicsItem *> startItems = items(line->line().p1());
        if (startItems.count() && startItems.first() == line)
            startItems.removeFirst();
        QList<QGraphicsItem *> endItems = items(line->line().p2());
        if (endItems.count() && endItems.first() == line)
            endItems.removeFirst();

        removeItem(line);
        delete line;

En primer lugar, debemos obtener los elementos (si los hay) situados en los puntos inicial y final de la línea. La propia línea es el primer elemento en estos puntos, por lo que la eliminamos de las listas. Como medida de precaución, comprobamos si las listas están vacías, aunque esto nunca debería ocurrir.

        if (startItems.count() > 0 && endItems.count() > 0 &&
            startItems.first()->type() == DiagramItem::Type &&
            endItems.first()->type() == DiagramItem::Type &&
            startItems.first() != endItems.first()) {
            DiagramItem *startItem = qgraphicsitem_cast<DiagramItem *>(startItems.first());
            DiagramItem *endItem = qgraphicsitem_cast<DiagramItem *>(endItems.first());
            Arrow *arrow = new Arrow(startItem, endItem);
            arrow->setColor(myLineColor);
            startItem->addArrow(arrow);
            endItem->addArrow(arrow);
            arrow->setZValue(-1000.0);
            addItem(arrow);
            arrow->updatePosition();
        }
    }

Ahora comprobamos si hay dos elementos diferentes de ` DiagramItems ` debajo de los puntos inicial y final de la línea. Si los hay, podemos crear una ` Arrow ` con los dos elementos. A continuación, se añade la flecha a cada elemento y, finalmente, a la escena. La flecha debe actualizarse para ajustar sus puntos inicial y final a los elementos. Establecemos el valor z de la flecha en -1000,0 porque queremos que siempre se dibuje por debajo de los elementos.

    line = nullptr;
    QGraphicsScene::mouseReleaseEvent(mouseEvent);
}

Aquí está la función « isItemChange() »:

bool DiagramScene::isItemChange(int type) const
{
    const QList<QGraphicsItem *> items = selectedItems();
    const auto cb = [type](const QGraphicsItem *item) { return item->type() == type; };
    return std::find_if(items.begin(), items.end(), cb) != items.end();
}

La escena tiene selección única, es decir, solo se puede seleccionar un elemento en un momento dado. El bucle «for» se ejecutará una vez con el elemento seleccionado o ninguna si no hay ningún elemento seleccionado. Se utiliza « isItemChange() » para comprobar si existe un elemento seleccionado y si, además, pertenece al diagrama especificado « type ».

Definición de la clase `DiagramItem`

class DiagramItem : public QGraphicsPolygonItem
{
public:
    enum { Type = UserType + 15 };
    enum DiagramType { Step, Conditional, StartEnd, Io };

    DiagramItem(DiagramType diagramType, QMenu *contextMenu, QGraphicsItem *parent = nullptr);

    void removeArrow(Arrow *arrow);
    void removeArrows();
    DiagramType diagramType() const { return myDiagramType; }
    QPolygonF polygon() const { return myPolygon; }
    void addArrow(Arrow *arrow);
    QPixmap image() const;
    int type() const override { return Type; }

protected:
    void contextMenuEvent(QGraphicsSceneContextMenuEvent *event) override;
    QVariant itemChange(GraphicsItemChange change, const QVariant &value) override;

private:
    DiagramType myDiagramType;
    QPolygonF myPolygon;
    QMenu *myContextMenu;
    QList<Arrow *> arrows;
};

DiagramItem representa una figura de diagrama de flujo en DiagramScene. Hereda de QGraphicsPolygonItem y tiene un polígono para cada figura. La enumeración DiagramType tiene un valor para cada una de las figuras del diagrama de flujo.

La clase dispone de una lista de las flechas que están conectadas a ella. Esto es necesario porque solo el elemento sabe cuándo se está moviendo (mediante la función ` itemChanged() `), momento en el que deben actualizarse las flechas. El elemento también puede dibujarse a sí mismo en un ` QPixmap ` mediante la función ` image() `. Esto se utiliza para los botones de herramientas de MainWindow; véase ` createColorToolButtonIcon() ` en MainWindow.

La enumeración Type es un identificador único de la clase. La utiliza qgraphicsitem_cast(), que realiza conversiones dinámicas de elementos gráficos. La constante UserType es el valor mínimo que puede tener un tipo de elemento gráfico personalizado.

Implementación de la clase `DiagramItem`

Empezamos echando un vistazo al constructor:

DiagramItem::DiagramItem(DiagramType diagramType, QMenu *contextMenu,
                         QGraphicsItem *parent)
    : QGraphicsPolygonItem(parent), myDiagramType(diagramType)
    , myContextMenu(contextMenu)
{
    QPainterPath path;
    switch (myDiagramType) {
        case StartEnd:
            path.moveTo(200, 50);
            path.arcTo(150, 0, 50, 50, 0, 90);
            path.arcTo(50, 0, 50, 50, 90, 90);
            path.arcTo(50, 50, 50, 50, 180, 90);
            path.arcTo(150, 50, 50, 50, 270, 90);
            path.lineTo(200, 25);
            myPolygon = path.toFillPolygon();
            break;
        case Conditional:
            myPolygon << QPointF(-100, 0) << QPointF(0, 100)
                      << QPointF(100, 0) << QPointF(0, -100)
                      << QPointF(-100, 0);
            break;
        case Step:
            myPolygon << QPointF(-100, -100) << QPointF(100, -100)
                      << QPointF(100, 100) << QPointF(-100, 100)
                      << QPointF(-100, -100);
            break;
        default:
            myPolygon << QPointF(-120, -80) << QPointF(-70, 80)
                      << QPointF(120, 80) << QPointF(70, -80)
                      << QPointF(-120, -80);
            break;
    }
    setPolygon(myPolygon);
    setFlag(QGraphicsItem::ItemIsMovable, true);
    setFlag(QGraphicsItem::ItemIsSelectable, true);
    setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
}

En el constructor creamos el polígono del elemento de acuerdo con diagramType. Los elementos QGraphicsItems no son movibles ni seleccionables por defecto, por lo que debemos establecer estas propiedades.

Aquí está la función ` removeArrow() `:

void DiagramItem::removeArrow(Arrow *arrow)
{
    arrows.removeAll(arrow);
}

removeArrow() Se utiliza para eliminar los elementos de « Arrow » cuando estos, o los « DiagramItems » a los que están conectados, se eliminan de la escena.

Aquí está la función « removeArrows() »:

void DiagramItem::removeArrows()
{
    // need a copy here since removeArrow() will
    // modify the arrows container
    const auto arrowsCopy = arrows;
    for (Arrow *arrow : arrowsCopy) {
        arrow->startItem()->removeArrow(arrow);
        arrow->endItem()->removeArrow(arrow);
        scene()->removeItem(arrow);
        delete arrow;
    }
}

Esta función se invoca cuando el elemento se elimina de la escena y elimina todas las flechas que están conectadas a dicho elemento. La flecha debe eliminarse de la lista « arrows » tanto de su elemento de inicio como de su elemento final. Dado que el elemento de inicio o el de fin es el objeto en el que se invoca actualmente esta función, debemos asegurarnos de trabajar con una copia de las flechas, ya que removeArrow() modifica este contenedor.

Esta es la función ` addArrow() `:

void DiagramItem::addArrow(Arrow *arrow)
{
    arrows.append(arrow);
}

Esta función simplemente añade el « arrow » a la lista « arrows » de los elementos.

Aquí está la función ` image() `:

QPixmap DiagramItem::image() const
{
    QPixmap pixmap(250, 250);
    pixmap.fill(Qt::transparent);
    QPainter painter(&pixmap);
    painter.setPen(QPen(Qt::black, 8));
    painter.translate(125, 125);
    painter.drawPolyline(myPolygon);

    return pixmap;
}

Esta función dibuja el polígono del elemento en un ` QPixmap`. En este ejemplo la utilizamos para crear iconos para los botones de herramientas de la caja de herramientas.

Esta es la función contextMenuEvent():

void DiagramItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
    scene()->clearSelection();
    setSelected(true);
    myContextMenu->popup(event->screenPos());
}

Mostramos el menú contextual. Dado que los clics con el botón derecho del ratón, que muestran el menú, no seleccionan elementos de forma predeterminada, establecemos el elemento seleccionado con setSelected(). Esto es necesario, ya que hay que seleccionar un elemento para cambiar su elevación con las acciones bringToFront y sendToBack.

Esta es la implementación de ` itemChange()`:

QVariant DiagramItem::itemChange(GraphicsItemChange change, const QVariant &value)
{
    if (change == QGraphicsItem::ItemPositionChange) {
        for (Arrow *arrow : std::as_const(arrows))
            arrow->updatePosition();
    }

    return value;
}

Si el elemento se ha desplazado, debemos actualizar las posiciones de las flechas conectadas a él. La implementación de ` QGraphicsItem ` no hace nada, por lo que simplemente devolvemos ` value`.

Definición de la clase `DiagramTextItem`

La clase ` TextDiagramItem ` hereda de ` QGraphicsTextItem ` y añade la posibilidad de mover elementos de texto editables. Los elementos `QGraphicsTextItem` editables están diseñados para permanecer fijos en su lugar, y la edición comienza cuando el usuario hace un clic simple sobre el elemento. Con ` DiagramTextItem `, la edición comienza con un doble clic, dejando el clic simple disponible para interactuar con el elemento y moverlo.

class DiagramTextItem : public QGraphicsTextItem
{
    Q_OBJECT

public:
    enum { Type = UserType + 3 };

    DiagramTextItem(QGraphicsItem *parent = nullptr);

    int type() const override { return Type; }

signals:
    void lostFocus(DiagramTextItem *item);
    void selectedChange(QGraphicsItem *item);

protected:
    QVariant itemChange(GraphicsItemChange change, const QVariant &value) override;
    void focusOutEvent(QFocusEvent *event) override;
    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) override;
};

Utilizamos itemChange() y focusOutEvent() para notificar a DiagramScene cuando el elemento de texto pierde el foco y se selecciona.

Reimplementamos las funciones que gestionan los eventos del ratón para que sea posible modificar el comportamiento del ratón de QGraphicsTextItem.

Implementación de DiagramTextItem

Empezamos por el constructor:

DiagramTextItem::DiagramTextItem(QGraphicsItem *parent)
    : QGraphicsTextItem(parent)
{
    setFlag(QGraphicsItem::ItemIsMovable);
    setFlag(QGraphicsItem::ItemIsSelectable);
}

Simplemente configuramos el elemento como movible y seleccionable, ya que estas opciones están desactivadas por defecto.

Aquí está la función ` itemChange() `:

QVariant DiagramTextItem::itemChange(GraphicsItemChange change,
                     const QVariant &value)
{
    if (change == QGraphicsItem::ItemSelectedHasChanged)
        emit selectedChange(this);
    return value;
}

Cuando se selecciona el elemento, emitimos la señal selectedChanged. El MainWindow utiliza esta señal para actualizar los widgets que muestran las propiedades de la fuente, de modo que reflejen la fuente del elemento de texto seleccionado.

Aquí está la función ` focusOutEvent() `:

void DiagramTextItem::focusOutEvent(QFocusEvent *event)
{
    setTextInteractionFlags(Qt::NoTextInteraction);
    emit lostFocus(this);
    QGraphicsTextItem::focusOutEvent(event);
}

DiagramScene utiliza la señal emitida cuando el elemento de texto pierde el foco para eliminar el elemento si está vacío, es decir, si no contiene texto.

Esta es la implementación de ` mouseDoubleClickEvent()`:

void DiagramTextItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
{
    if (textInteractionFlags() == Qt::NoTextInteraction)
        setTextInteractionFlags(Qt::TextEditorInteraction);
    QGraphicsTextItem::mouseDoubleClickEvent(event);
}

Cuando recibimos un evento de doble clic, hacemos que el elemento sea editable llamando a QGraphicsTextItem::setTextInteractionFlags(). A continuación, reenviamos el doble clic al propio elemento.

Definición de la clase «Arrow»

La clase ` Arrow ` es un elemento gráfico que conecta dos elementos ` DiagramItems`. Dibuja una punta de flecha en uno de los elementos. Para ello, el elemento debe dibujarse a sí mismo y también reimplementar los métodos utilizados por la escena gráfica para comprobar colisiones y selecciones. La clase hereda del elemento `QGraphicsLine`, dibuja la punta de flecha y se desplaza junto con los elementos que conecta.

class Arrow : public QGraphicsLineItem
{
public:
    enum { Type = UserType + 4 };

    Arrow(DiagramItem *startItem, DiagramItem *endItem,
          QGraphicsItem *parent = nullptr);

    int type() const override { return Type; }
    QRectF boundingRect() const override;
    QPainterPath shape() const override;
    void setColor(const QColor &color) { myColor = color; }
    DiagramItem *startItem() const { return myStartItem; }
    DiagramItem *endItem() const { return myEndItem; }

    void updatePosition();

protected:
    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
               QWidget *widget = nullptr) override;

private:
    DiagramItem *myStartItem;
    DiagramItem *myEndItem;
    QPolygonF arrowHead;
    QColor myColor = Qt::black;
};

El color del elemento se puede establecer con ` setColor()`.

boundingRect() y ` shape() ` se reimplementan a partir de ` QGraphicsLineItem ` y son utilizados por la escena para comprobar colisiones y selecciones.

Al llamar a ` updatePosition() `, la flecha recalcula su posición y el ángulo de la punta. ` paint() ` se ha reimplementado para que podamos dibujar una flecha en lugar de una simple línea entre elementos.

myStartItem y myEndItem son los elementos del diagrama que conecta la flecha. La flecha se dibuja con la punta apuntando hacia el elemento final. arrowHead es un polígono de tres vértices que utilizamos para dibujar la punta de la flecha.

Implementación de la clase Arrow

El constructor de la clase ` Arrow ` tiene este aspecto:

Arrow::Arrow(DiagramItem *startItem, DiagramItem *endItem, QGraphicsItem *parent)
    : QGraphicsLineItem(parent), myStartItem(startItem), myEndItem(endItem)
{
    setFlag(QGraphicsItem::ItemIsSelectable, true);
    setPen(QPen(myColor, 2, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
}

Establecemos los elementos de diagrama de inicio y fin de la flecha. La punta de la flecha se dibujará donde la línea se cruza con el elemento final.

Aquí está la función ` boundingRect() `:

QRectF Arrow::boundingRect() const
{
    qreal extra = (pen().width() + 20) / 2.0;

    return QRectF(line().p1(), QSizeF(line().p2().x() - line().p1().x(),
                                      line().p2().y() - line().p1().y()))
        .normalized()
        .adjusted(-extra, -extra, extra, extra);
}

Tenemos que reimplementar esta función porque la flecha es más grande que el rectángulo delimitador de ` QGraphicsLineItem`. La escena gráfica utiliza el rectángulo delimitador para saber qué regiones de la escena debe actualizar.

Esta es la función ` shape() `:

QPainterPath Arrow::shape() const
{
    QPainterPath path = QGraphicsLineItem::shape();
    path.addPolygon(arrowHead);
    return path;
}

La función `shape` devuelve un ` QPainterPath ` que tiene la forma exacta del elemento. La función ` QGraphicsLineItem::shape()` devuelve una ruta con una línea dibujada con el lápiz actual, por lo que solo tenemos que añadir la punta de la flecha. Esta función se utiliza para comprobar colisiones y selecciones con el ratón.

Aquí está la ranura « updatePosition() »:

void Arrow::updatePosition()
{
    QLineF line(mapFromItem(myStartItem, 0, 0), mapFromItem(myEndItem, 0, 0));
    setLine(line);
}

Esta ranura actualiza la flecha estableciendo los puntos inicial y final de su línea en el centro de los elementos que conecta.

Aquí está la función « paint() »:

void Arrow::paint(QPainter *painter, const QStyleOptionGraphicsItem *,
                  QWidget *)
{
    if (myStartItem->collidesWithItem(myEndItem))
        return;

    QPen myPen = pen();
    myPen.setColor(myColor);
    qreal arrowSize = 20;
    painter->setPen(myPen);
    painter->setBrush(myColor);

Si los elementos inicial y final colisionan, no dibujamos la flecha; el algoritmo que utilizamos para encontrar el punto en el que debe dibujarse la flecha puede fallar si los elementos colisionan.

En primer lugar, configuramos el lápiz y el pincel que utilizaremos para dibujar la flecha.

    QLineF centerLine(myStartItem->pos(), myEndItem->pos());
    QPolygonF endPolygon = myEndItem->polygon();
    QPointF p1 = endPolygon.first() + myEndItem->pos();
    QPointF intersectPoint;
    for (int i = 1; i < endPolygon.count(); ++i) {
        QPointF p2 = endPolygon.at(i) + myEndItem->pos();
        QLineF polyLine = QLineF(p1, p2);
        QLineF::IntersectionType intersectionType =
            polyLine.intersects(centerLine, &intersectPoint);
        if (intersectionType == QLineF::BoundedIntersection)
            break;
        p1 = p2;
    }

    setLine(QLineF(intersectPoint, myStartItem->pos()));

A continuación, debemos hallar la posición en la que dibujar la punta de la flecha. La punta debe dibujarse donde la línea y el elemento final se cruzan. Para ello, tomamos la línea entre cada punto del polígono y comprobamos si se cruza con la línea de la flecha. Dado que los puntos inicial y final de la línea están situados en el centro de los elementos, la línea de la flecha debería intersectar una y solo una de las líneas del polígono. Ten en cuenta que los puntos del polígono son relativos al sistema de coordenadas local del elemento. Por lo tanto, debemos sumar la posición del elemento final para que las coordenadas sean relativas a la escena.

    double angle = std::atan2(-line().dy(), line().dx());

    QPointF arrowP1 = line().p1() + QPointF(sin(angle + M_PI / 3) * arrowSize,
                                    cos(angle + M_PI / 3) * arrowSize);
    QPointF arrowP2 = line().p1() + QPointF(sin(angle + M_PI - M_PI / 3) * arrowSize,
                                    cos(angle + M_PI - M_PI / 3) * arrowSize);

    arrowHead.clear();
    arrowHead << line().p1() << arrowP1 << arrowP2;

Calculamos el ángulo entre el eje x y la línea de la flecha. Tenemos que girar la punta de la flecha según este ángulo para que siga la dirección de la flecha. Si el ángulo es negativo, debemos invertir la dirección de la flecha.

A continuación, podemos calcular los tres vértices del polígono de la punta de la flecha. Uno de los vértices es el extremo de la línea, que ahora es la intersección entre la línea de la flecha y el polígono final. Después, borramos el polígono arrowHead de la punta de flecha calculada anteriormente y establecemos estos nuevos vértices.

    painter->drawLine(line());
    painter->drawPolygon(arrowHead);
    if (isSelected()) {
        painter->setPen(QPen(myColor, 1, Qt::DashLine));
        QLineF myLine = line();
        myLine.translate(0, 4.0);
        painter->drawLine(myLine);
        myLine.translate(0,-8.0);
        painter->drawLine(myLine);
    }
}

Si la línea está seleccionada, dibujamos dos líneas punteadas que sean paralelas a la línea de la flecha. No utilizamos la implementación predeterminada, que utiliza ` boundingRect()`, ya que el rectángulo delimitador de ` QRect ` es considerablemente más grande que la línea.

Proyecto de ejemplo en @code.qt.io

© 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.