En esta página

Ejemplo de tableta

Este ejemplo muestra cómo utilizar una tableta Wacom en aplicaciones Qt.

Aplicación que muestra un área de dibujo

Al utilizar una tableta con aplicaciones Qt, se generan eventos « QTabletEvent». Es necesario reimplementar el controlador de eventos ` tabletEvent()` si se desea gestionar los eventos de la tableta. Se generan eventos cuando la herramienta (el lápiz óptico) utilizada para dibujar se acerca o se aleja de la tableta (es decir, cuando está cerca de ella pero sin presionarla), cuando se presiona y se suelta la herramienta, cuando se mueve la herramienta por la tableta, y cuando se pulsa o se suelta uno de los botones de la herramienta.

La información disponible en QTabletEvent depende del dispositivo utilizado. Este ejemplo puede gestionar una tableta con hasta tres herramientas de dibujo diferentes: un lápiz óptico, un aerógrafo y un lápiz artístico. Para cualquiera de ellas, el evento contendrá la posición de la herramienta, la presión sobre la tableta, el estado de los botones, la inclinación vertical y la inclinación horizontal (es decir, el ángulo entre el dispositivo y la perpendicular a la tableta, si el hardware de la tableta puede proporcionarlo). El aerógrafo cuenta con una rueda de dedo; su posición también está disponible en el evento de la tableta. El lápiz artístico permite girar alrededor del eje perpendicular a la superficie de la tableta, lo que permite utilizarlo para caligrafía.

En este ejemplo implementamos un programa de dibujo. Puedes utilizar el lápiz óptico para dibujar en la tableta como si utilizases un lápiz sobre papel. Al dibujar con el aerógrafo se obtiene un chorro de pintura virtual; la rueda de dedo se utiliza para modificar la densidad del chorro. Al dibujar con el lápiz artístico, se obtiene una línea cuyo grosor y ángulo del extremo dependen de la rotación del lápiz. La presión y la inclinación también se pueden asignar para modificar los valores de alfa y saturación del color, así como el grosor del trazo.

El ejemplo consta de lo siguiente:

  • La clase ` MainWindow ` hereda de ` QMainWindow`, crea los menús y conecta sus ranuras y señales.
  • La clase ` TabletCanvas ` hereda de ` QWidget ` y recibe eventos de la tableta. Utiliza los eventos para dibujar en un mapa de píxeles fuera de pantalla y, a continuación, lo representa.
  • La clase ` TabletApplication ` hereda de ` QApplication`. Esta clase gestiona los eventos de proximidad de la tableta.
  • La función ` main() ` crea un ` MainWindow ` y lo muestra como una ventana de nivel superior.

Definición de la clase MainWindow

La clase ` MainWindow ` crea un objeto ` TabletCanvas ` y lo establece como su widget central.

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(TabletCanvas *canvas);

private slots:
    void setBrushColor();
    void setAlphaValuator(QAction *action);
    void setLineWidthValuator(QAction *action);
    void setSaturationValuator(QAction *action);
    void setEventCompression(bool compress);
    bool save();
    void load();
    void clear();
    void about();

private:
    void createMenus();

    TabletCanvas *m_canvas;
    QColorDialog *m_colorDialog = nullptr;
};

createMenus() Configura los menús con las acciones. Contamos con un « QActionGroup » para las acciones que modifican el canal alfa, la saturación del color y el grosor de la línea, respectivamente. Los grupos de acciones están conectados a las ranuras « setAlphaValuator() », « setSaturationValuator() » y « setLineWidthValuator() », que llaman a funciones en « TabletCanvas ».

Implementación de la clase MainWindow

Comenzamos echando un vistazo al constructor MainWindow():

MainWindow::MainWindow(TabletCanvas *canvas)
    : m_canvas(canvas)
{
    createMenus();
    setWindowTitle(tr("Tablet Example"));
    setCentralWidget(m_canvas);
    QCoreApplication::setAttribute(Qt::AA_CompressHighFrequencyEvents);
}

En el constructor llamamos a ` createMenus() ` para crear todas las acciones y menús, y establecemos el lienzo como el widget central.

void MainWindow::createMenus()
{
    QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
    fileMenu->addAction(tr("&Open..."), QKeySequence::Open, this, &MainWindow::load);
    fileMenu->addAction(tr("&Save As..."), QKeySequence::SaveAs, this, &MainWindow::save);
    fileMenu->addAction(tr("&New"), QKeySequence::New, this, &MainWindow::clear);
    fileMenu->addAction(tr("E&xit"), QKeySequence::Quit, this, &MainWindow::close);

    QMenu *brushMenu = menuBar()->addMenu(tr("&Brush"));
    brushMenu->addAction(tr("&Brush Color..."), tr("Ctrl+B"), this, &MainWindow::setBrushColor);

Al principio de ` createMenus() `, rellenamos el menú «Archivo ». Utilizamos una sobrecarga de ` addAction()`, introducida en Qt 5.6, para crear un elemento de menú con un atajo de teclado (y, opcionalmente, un icono), añadirlo a su menú y conectarlo a una ranura, todo ello con una sola línea de código. Utilizamos ` QKeySequence ` para obtener los atajos de teclado estándar específicos de cada plataforma para estos elementos de menú comunes.

También completamos el menú «Pincel ». El comando para cambiar de pincel no suele tener un atajo estándar, por lo que utilizamos tr() para permitir que el atajo se traduzca junto con la traducción del idioma de la aplicación.

Ahora veremos la creación de un grupo de acciones mutuamente excluyentes en un submenú del menú «Tableta», para seleccionar qué propiedad de cada QTabletEvent se utilizará para variar la translucidez (canal alfa) de la línea que se está dibujando o del color que se está aplicando con el aerógrafo.

    QMenu *alphaChannelMenu = tabletMenu->addMenu(tr("&Alpha Channel"));
    QAction *alphaChannelPressureAction = alphaChannelMenu->addAction(tr("&Pressure"));
    alphaChannelPressureAction->setData(TabletCanvas::PressureValuator);
    alphaChannelPressureAction->setCheckable(true);

    QAction *alphaChannelTangentialPressureAction = alphaChannelMenu->addAction(tr("T&angential Pressure"));
    alphaChannelTangentialPressureAction->setData(TabletCanvas::TangentialPressureValuator);
    alphaChannelTangentialPressureAction->setCheckable(true);
    alphaChannelTangentialPressureAction->setChecked(true);

    QAction *alphaChannelTiltAction = alphaChannelMenu->addAction(tr("&Tilt"));
    alphaChannelTiltAction->setData(TabletCanvas::TiltValuator);
    alphaChannelTiltAction->setCheckable(true);

    QAction *noAlphaChannelAction = alphaChannelMenu->addAction(tr("No Alpha Channel"));
    noAlphaChannelAction->setData(TabletCanvas::NoValuator);
    noAlphaChannelAction->setCheckable(true);

    QActionGroup *alphaChannelGroup = new QActionGroup(this);
    alphaChannelGroup->addAction(alphaChannelPressureAction);
    alphaChannelGroup->addAction(alphaChannelTangentialPressureAction);
    alphaChannelGroup->addAction(alphaChannelTiltAction);
    alphaChannelGroup->addAction(noAlphaChannelAction);
    connect(alphaChannelGroup, &QActionGroup::triggered,
            this, &MainWindow::setAlphaValuator);

Queremos que el usuario pueda elegir si el componente alfa del color de dibujo debe modularse en función de la presión de la tableta, la inclinación o la posición de la ruedecilla de la herramienta aerógrafo. Tenemos una acción para cada opción y una acción adicional para elegir no cambiar el alfa, es decir, para mantener el color opaco. Hacemos que las acciones sean seleccionables; el « alphaChannelGroup » se encargará entonces de que solo una de las acciones esté marcada en cada momento. La señal « triggered() » se emite desde el grupo cuando se marca una acción, por lo que la conectamos a « MainWindow::setAlphaValuator() ». Este tendrá que saber a qué propiedad (valuator) de « QTabletEvent » debe prestar atención a partir de ahora, por lo que utilizamos la propiedad « QAction::data » para transmitir esta información. (Para que esto sea posible, la enumeración Valuator debe ser un metatipo registrado, de modo que pueda insertarse en un QVariant. Esto se consigue mediante la declaración Q_ENUM en tabletcanvas.h.)

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

void MainWindow::setAlphaValuator(QAction *action)
{
    m_canvas->setAlphaChannelValuator(qvariant_cast<TabletCanvas::Valuator>(action->data()));
}

Simplemente tiene que recuperar la enumeración Valuator desde QAction::data() y pasarla a TabletCanvas::setAlphaChannelValuator(). Si no estuviéramos utilizando la propiedad data, tendríamos que comparar el propio puntero QAction, por ejemplo, en una instrucción switch. Pero eso requeriría mantener punteros a cada QAction en variables de clase, con fines de comparación.

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

void MainWindow::setBrushColor()
{
    if (!m_colorDialog) {
        m_colorDialog = new QColorDialog(this);
        m_colorDialog->setModal(false);
        m_colorDialog->setCurrentColor(m_canvas->color());
        connect(m_colorDialog, &QColorDialog::colorSelected, m_canvas, &TabletCanvas::setColor);
    }
    m_colorDialog->setVisible(true);
}

Realizamos una inicialización diferida de un ` QColorDialog ` la primera vez que el usuario selecciona «Color del pincel...» en el menú o mediante el atajo de acción. Mientras el cuadro de diálogo esté abierto, cada vez que el usuario elija un color diferente, se llamará a « TabletCanvas::setColor() » para cambiar el color de dibujo. Al tratarse de un cuadro de diálogo no modal, el usuario tiene la libertad de dejarlo abierto, para poder cambiar los colores de forma cómoda y frecuente, o de cerrarlo y volver a abrirlo más tarde.

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

bool MainWindow::save()
{
    QString path = QDir::currentPath() + "/untitled.png";
    QString fileName = QFileDialog::getSaveFileName(this, tr("Save Picture"),
                             path);
    bool success = m_canvas->saveImage(fileName);
    if (!success)
        QMessageBox::information(this, "Error Saving Picture",
                                 "Could not save the image");
    return success;
}

Utilizamos el control « QFileDialog » para que el usuario seleccione un archivo en el que guardar el dibujo y, a continuación, llamamos a TabletCanvas::saveImage() para guardarlo realmente en el archivo.

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

void MainWindow::load()
{
    QString fileName = QFileDialog::getOpenFileName(this, tr("Open Picture"),
                                                    QDir::currentPath());

    if (!m_canvas->loadImage(fileName))
        QMessageBox::information(this, "Error Opening Picture",
                                 "Could not open picture");
}

Permitimos que el usuario seleccione el archivo de imagen que se va a abrir con un ` QFileDialog`; a continuación, le pedimos al lienzo que cargue la imagen con ` loadImage()`.

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

void MainWindow::about()
{
    QMessageBox::about(this, tr("About Tablet Example"),
                       tr("This example shows how to use a graphics drawing tablet in Qt."));
}

Mostramos un cuadro de mensaje con una breve descripción del ejemplo.

Definición de la clase TabletCanvas

La clase ` TabletCanvas ` proporciona una superficie en la que el usuario puede dibujar con una tableta.

class TabletCanvas : public QWidget
{
    Q_OBJECT

public:
    enum Valuator { PressureValuator, TangentialPressureValuator,
                    TiltValuator, VTiltValuator, HTiltValuator, NoValuator };
    Q_ENUM(Valuator)

    TabletCanvas();

    bool saveImage(const QString &file);
    bool loadImage(const QString &file);
    void clear();
    void setAlphaChannelValuator(Valuator type)
        { m_alphaChannelValuator = type; }
    void setColorSaturationValuator(Valuator type)
        { m_colorSaturationValuator = type; }
    void setLineWidthType(Valuator type)
        { m_lineWidthValuator = type; }
    void setColor(const QColor &c)
        { if (c.isValid()) m_color = c; }
    QColor color() const
        { return m_color; }
    void setTabletDevice(QTabletEvent *event)
        { updateCursor(event); }

protected:
    void tabletEvent(QTabletEvent *event) override;
    void paintEvent(QPaintEvent *event) override;
    void resizeEvent(QResizeEvent *event) override;

private:
    void initPixmap();
    void paintPixmap(QPainter &painter, QTabletEvent *event);
    Qt::BrushStyle brushPattern(qreal value);
    static qreal pressureToWidth(qreal pressure);
    void updateBrush(const QTabletEvent *event);
    void updateCursor(const QTabletEvent *event);

    Valuator m_alphaChannelValuator = TangentialPressureValuator;
    Valuator m_colorSaturationValuator = NoValuator;
    Valuator m_lineWidthValuator = PressureValuator;
    QColor m_color = Qt::red;
    QPixmap m_pixmap;
    QBrush m_brush;
    QPen m_pen;
    bool m_deviceDown = false;

    struct Point {
        QPointF pos;
        qreal pressure = 0;
        qreal rotation = 0;
    } lastPoint;
};

El lienzo permite modificar el canal alfa, la saturación del color y el grosor de la línea del trazo. Disponemos de una enumeración que recoge las propiedades de ` QTabletEvent ` con las que es posible modular estos parámetros. Mantenemos una variable privada para cada una de ellas: ` m_alphaChannelValuator`, ` m_colorSaturationValuator ` y ` m_lineWidthValuator`, y proporcionamos funciones de acceso para ellas.

Dibujamos sobre un QPixmap con m_pen y m_brush utilizando m_color. Cada vez que se recibe un QTabletEvent, se dibuja el trazo desde lastPoint hasta el punto indicado en el QTabletEvent actual, y a continuación se guardan la posición y la rotación en lastPoint para la próxima vez. Las funciones saveImage() y loadImage() guardan y cargan el QPixmap en el disco. El mapa de píxeles se dibuja en el widget en paintEvent().

La interpretación de los eventos procedentes de la tableta se realiza en tabletEvent(), y paintPixmap(), updateBrush() y updateCursor() son funciones auxiliares utilizadas por tabletEvent().

Implementación de la clase TabletCanvas

Empezamos echando un vistazo al constructor:

TabletCanvas::TabletCanvas()
    : QWidget(nullptr), m_brush(m_color)
    , m_pen(m_brush, 1.0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin)
{
    resize(500, 500);
    setAutoFillBackground(true);
    setAttribute(Qt::WA_TabletTracking);
}

En el constructor inicializamos la mayoría de nuestras variables de clase.

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

bool TabletCanvas::saveImage(const QString &file)
{
    return m_pixmap.save(file);
}

QPixmap implementa la funcionalidad para guardarse en el disco, así que simplemente llamamos a ` save()`.

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

bool TabletCanvas::loadImage(const QString &file)
{
    bool success = m_pixmap.load(file);

    if (success) {
        update();
        return true;
    }
    return false;
}

Simplemente llamamos a ` load()`, que carga la imagen desde file.

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

void TabletCanvas::tabletEvent(QTabletEvent *event)
{
    switch (event->type()) {
        case QEvent::TabletPress:
            if (!m_deviceDown) {
                m_deviceDown = true;
                lastPoint.pos = event->position();
                lastPoint.pressure = event->pressure();
                lastPoint.rotation = event->rotation();
            }
            break;
        case QEvent::TabletMove:
#ifndef Q_OS_IOS
            if (event->pointingDevice() && event->pointingDevice()->capabilities().testFlag(QPointingDevice::Capability::Rotation))
                updateCursor(event);
#endif
            if (m_deviceDown) {
                updateBrush(event);
                QPainter painter(&m_pixmap);
                paintPixmap(painter, event);
                lastPoint.pos = event->position();
                lastPoint.pressure = event->pressure();
                lastPoint.rotation = event->rotation();
            }
            break;
        case QEvent::TabletRelease:
            if (m_deviceDown && event->buttons() == Qt::NoButton)
                m_deviceDown = false;
            update();
            break;
        default:
            break;
    }
    event->accept();
}

Recibimos tres tipos de eventos en esta función: TabletPress, TabletRelease y TabletMove, que se generan cuando se pulsa, se levanta o se desplaza una herramienta de dibujo sobre la tableta. Establecemos m_deviceDown en true cuando se pulsa una herramienta sobre la tableta; así sabemos que debemos dibujar cuando recibamos eventos de movimiento. Hemos implementado updateBrush() para actualizar m_brush y m_pen en función de a cuál de las propiedades de eventos de la tableta haya decidido prestar atención el usuario. La función updateCursor() selecciona un cursor que representa la herramienta de dibujo en uso, de modo que, al pasar la herramienta cerca de la tableta, se puede ver qué tipo de trazo se va a realizar.

void TabletCanvas::updateCursor(const QTabletEvent *event)
{
    QCursor cursor;
    if (event->type() != QEvent::TabletLeaveProximity) {
        if (event->pointerType() == QPointingDevice::PointerType::Eraser) {
            cursor = QCursor(QPixmap(":/images/cursor-eraser.png"), 3, 28);
        } else {
            switch (event->deviceType()) {
            case QInputDevice::DeviceType::Stylus:
                if (event->pointingDevice()->capabilities().testFlag(QPointingDevice::Capability::Rotation)) {
                    QImage origImg(QLatin1String(":/images/cursor-felt-marker.png"));
                    QImage img(32, 32, QImage::Format_ARGB32);
                    QColor solid = m_color;
                    solid.setAlpha(255);
                    img.fill(solid);
                    QPainter painter(&img);
                    QTransform transform = painter.transform();
                    transform.translate(16, 16);
                    transform.rotate(event->rotation());
                    painter.setTransform(transform);
                    painter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
                    painter.drawImage(-24, -24, origImg);
                    painter.setCompositionMode(QPainter::CompositionMode_HardLight);
                    painter.drawImage(-24, -24, origImg);
                    painter.end();
                    cursor = QCursor(QPixmap::fromImage(img), 16, 16);
                } else {
                    cursor = QCursor(QPixmap(":/images/cursor-pencil.png"), 0, 0);
                }
                break;
            case QInputDevice::DeviceType::Airbrush:
                cursor = QCursor(QPixmap(":/images/cursor-airbrush.png"), 3, 4);
                break;
            default:
                break;
            }
        }
    }
    setCursor(cursor);
}

Si se está utilizando un lápiz artístico (RotationStylus), también se llama a updateCursor() para cada evento TabletMove, y se muestra un cursor girado para que puedas ver el ángulo de la punta del lápiz.

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

void TabletCanvas::initPixmap()
{
    qreal dpr = devicePixelRatio();
    QPixmap newPixmap = QPixmap(qRound(width() * dpr), qRound(height() * dpr));
    newPixmap.setDevicePixelRatio(dpr);
    newPixmap.fill(Qt::white);
    QPainter painter(&newPixmap);
    if (!m_pixmap.isNull())
        painter.drawPixmap(0, 0, m_pixmap);
    painter.end();
    m_pixmap = newPixmap;
}

void TabletCanvas::paintEvent(QPaintEvent *event)
{
    if (m_pixmap.isNull())
        initPixmap();
    QPainter painter(this);
    QRect pixmapPortion = QRect(event->rect().topLeft() * devicePixelRatio(),
                                event->rect().size() * devicePixelRatio());
    painter.drawPixmap(event->rect().topLeft(), m_pixmap, pixmapPortion);
}

La primera vez que Qt llama a `paintEvent()`, `m_pixmap` se construye con los valores por defecto, por lo que ` QPixmap::isNull()` devuelve ` true`. Ahora que sabemos en qué pantalla vamos a realizar el renderizado, podemos crear un mapa de píxeles con la resolución adecuada. El tamaño del mapa de píxeles con el que rellenamos la ventana depende de la resolución de la pantalla, ya que el ejemplo no admite el zoom; además, puede darse el caso de que una pantalla tenga un DPI alto y otra no. También tenemos que dibujar el fondo, ya que el valor por defecto es el gris.

Después, simplemente dibujamos el mapa de píxeles en la esquina superior izquierda del widget.

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

void TabletCanvas::paintPixmap(QPainter&painter, QTabletEvent*event)
{
    static qreal maxPenRadius = pressureToWidth(1.0);
    painter.setRenderHint(QPainter::Antialiasing);

    switch (event->deviceType()) {
        case QInputDevice::DeviceType::Airbrush:
            {
                painter.setPen(Qt::NoPen);
                QRadialGradient grad(lastPoint.pos, m_pen.widthF() * 10.0);
                QColor color = m_brush.color();
                color.setAlphaF(color.alphaF() * 0.25);
                grad.setColorAt(0, m_brush.color());
                grad.setColorAt(0.5, Qt::transparent);
                painter.setBrush(grad);
                qreal radio = grad.radius();
                painter.drawEllipse(event->position(), radio, radio);
                update(QRect(event->position().toPoint() - QPoint(radius, radius), QSize(radio * 2, radio * 2)));
            }
            break;
        case QInputDevice::DeviceType::Puck:
        case QInputDevice::DeviceType::Mouse:
            {
                const QString error(tr("Este dispositivo de entrada no es compatible con el ejemplo."));
#if QT_CONFIG(statustip)
                QStatusTipEvent status(error);
                QCoreApplication::sendEvent(this, &status);
#else
                qWarning() << error;
#endif
            }
            break;
        por defecto:
            {
                const QString error(tr("Dispositivo tablet desconocido: se trata como un lápiz óptico"));
#if QT_CONFIG(statustip)
                QStatusTipEvent status(error);
                QCoreApplication::sendEvent(this, &status);
#else
                qWarning() << error;
#endif
            }
            Q_FALLTHROUGH();
        case QInputDevice::DeviceType::Stylus:
            if (event->pointingDevice()->capabilities().testFlag(QPointingDevice::Capability::Rotation)) {
                m_brush.setStyle(Qt::SolidPattern);
                painter.setPen(Qt::NoPen);
                painter.setBrush(m_brush);
                QPolygonF poly;
                qreal halfWidth = pressureToWidth(lastPoint.pressure);
                QPointF brushAdjust(qSin(qDegreesToRadians(-lastPoint.rotation)) * halfWidth,
                                    qCos(qDegreesToRadians(-lastPoint.rotation)) * halfWidth);
                poly << lastPoint.pos + brushAdjust;
                poly << lastPoint.pos - brushAdjust;
                halfWidth = m_pen.widthF();
                brushAdjust = QPointF(qSin(qDegreesToRadians(-event->rotation())) * halfWidth,
                                      qCos(qDegreesToRadians(-event->rotation())) * halfWidth);
                poly << event->position() - brushAdjust;
                poly << event->position() + brushAdjust;
                painter.drawConvexPolygon(poly);
                update(poly.boundingRect().toRect());
            } else {
                painter.setPen(m_pen);
                painter.drawLine(lastPoint.pos, event->position());
                update(QRect(lastPoint.pos.toPoint(), event->position().toPoint()).normalized()
                       .adjusted(-maxPenRadius, -maxPenRadius, maxPenRadius, maxPenRadius));
            }
            break;
    }
}

En esta función dibujamos sobre el mapa de píxeles en función del movimiento de la herramienta. Si la herramienta utilizada en la tableta es un lápiz óptico, queremos trazar una línea desde la última posición conocida hasta la posición actual. También suponemos que este es un tratamiento razonable para cualquier dispositivo desconocido, pero actualizamos la barra de estado con una advertencia. Si se trata de un aerógrafo, queremos dibujar un círculo relleno con un degradado suave, cuya densidad puede depender de diversos parámetros del evento. Por defecto, depende de la presión tangencial, que es la posición de la ruedecilla del dedo en el aerógrafo. Si la herramienta es un lápiz óptico giratorio, simulamos un rotulador de fieltro dibujando segmentos de trazo trapezoidales.

        case QInputDevice::DeviceType::Airbrush:
            {
                painter.setPen(Qt::NoPen);
                QRadialGradient grad(lastPoint.pos, m_pen.widthF() * 10.0);
                QColor color = m_brush.color();
                color.setAlphaF(color.alphaF() * 0.25);
                grad.setColorAt(0, m_brush.color());
                grad.setColorAt(0.5, Qt::transparent);
                painter.setBrush(grad);
                qreal radius = grad.radius();
                painter.drawEllipse(event->position(), radius, radius);
                update(QRect(event->position().toPoint() - QPoint(radius, radius), QSize(radius * 2, radius * 2)));
            }
            break;

En updateBrush() configuramos el lápiz y el pincel utilizados para dibujar de modo que coincidan con m_alphaChannelValuator, m_lineWidthValuator, m_colorSaturationValuator y m_color. Examinaremos el código para configurar m_brush y m_pen para cada una de estas variables:

void TabletCanvas::updateBrush(const QTabletEvent *event)
{
    int hue, saturation, value, alpha;
    m_color.getHsv(&hue, &saturation, &value, &alpha);

    int vValue = int(((event->yTilt() + 60.0) / 120.0) * 255);
    int hValue = int(((event->xTilt() + 60.0) / 120.0) * 255);

Recuperamos los valores de matiz, saturación, valor y alfa del color de dibujo actual. hValue y vValue se establecen en la inclinación horizontal y vertical, respectivamente, como un número comprendido entre 0 y 255. Los valores originales están expresados en grados, entre -60 y 60; es decir, 0 equivale a -60, 127 equivale a 0 y 255 equivale a 60 grados. El ángulo medido es el que forma el dispositivo con la perpendicular a la tableta (véase QTabletEvent para ver una ilustración).

    switch (m_alphaChannelValuator) {
        case PressureValuator:
            m_color.setAlphaF(event->pressure());
            break;
        case TangentialPressureValuator:
            if (event->deviceType() == QInputDevice::DeviceType::Airbrush)
                m_color.setAlphaF(qMax(0.01, (event->tangentialPressure() + 1.0) / 2.0));
            else
                m_color.setAlpha(255);
            break;
        case TiltValuator:
            m_color.setAlpha(std::max(std::abs(vValue - 127),
                                      std::abs(hValue - 127)));
            break;
        default:
            m_color.setAlpha(255);
    }

El canal alfa de QColor se expresa como un número entre 0 y 255, donde 0 es transparente y 255 es opaco, o como un número de coma flotante donde 0 es transparente y 1,0 es opaco. pressure() devuelve la presión como un qreal entre 0,0 y 1,0. Obtenemos los valores alfa más pequeños (es decir, el color es más transparente) cuando el lápiz está perpendicular a la tableta. Seleccionamos el mayor de los valores de inclinación vertical y horizontal.

    switch (m_colorSaturationValuator) {
        case VTiltValuator:
            m_color.setHsv(hue, vValue, value, alpha);
            break;
        case HTiltValuator:
            m_color.setHsv(hue, hValue, value, alpha);
            break;
        case PressureValuator:
            m_color.setHsv(hue, int(event->pressure() * 255.0), value, alpha);
            break;
        default:
            ;
    }

La saturación del color en el modelo de color HSV puede expresarse como un número entero entre 0 y 255 o como un valor de coma flotante entre 0 y 1. Hemos optado por representar el alfa como un número entero, por lo que llamamos a setHsv() con valores enteros. Eso significa que tenemos que multiplicar la presión por un número entre 0 y 255.

    switch (m_lineWidthValuator) {
        case PressureValuator:
            m_pen.setWidthF(pressureToWidth(event->pressure()));
            break;
        case TiltValuator:
            m_pen.setWidthF(std::max(std::abs(vValue - 127),
                                     std::abs(hValue - 127)) / 12);
            break;
        default:
            m_pen.setWidthF(1);
    }

El grosor del trazo del lápiz puede aumentar con la presión, si así se elige. Pero cuando el grosor del lápiz se controla mediante la inclinación, hacemos que el grosor aumente con el ángulo entre la herramienta y la perpendicular a la tableta.

    if (event->pointerType() == QPointingDevice::PointerType::Eraser) {
        m_brush.setColor(Qt::white);
        m_pen.setColor(Qt::white);
        m_pen.setWidthF(event->pressure() * 10 + 1);
    } else {
        m_brush.setColor(m_color);
        m_pen.setColor(m_color);
    }
}

Por último, comprobamos si el puntero es el lápiz óptico o el borrador. Si es el borrador, establecemos el color como el color de fondo del mapa de píxeles y dejamos que la presión determine el grosor del trazo; en caso contrario, establecemos los colores que hayamos decidido previamente en la función.

Definición de la clase TabletApplication

En esta clase heredamos de ` QApplication `, ya que queremos reimplementar la función ` event()`.

class TabletApplication : public QApplication
{
    Q_OBJECT

public:
    using QApplication::QApplication;

    bool event(QEvent *event) override;
    void setCanvas(TabletCanvas *canvas)
        { m_canvas = canvas; }

private:
    TabletCanvas *m_canvas = nullptr;
};

TabletApplication existe como subclase de ` QApplication ` con el fin de recibir eventos de proximidad de la tableta y reenviarlos a ` TabletCanvas`. Los eventos ` TabletEnterProximity ` y ` TabletLeaveProximity ` se envían al objeto ` QApplication `, mientras que el resto de eventos de la tableta se envían al controlador ` event() ` de ` QWidget`, que a su vez los reenvía a ` tabletEvent()`.

Implementación de la clase `TabletApplication`

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

bool TabletApplication::event(QEvent *event)
{
    if (event->type() == QEvent::TabletEnterProximity ||
        event->type() == QEvent::TabletLeaveProximity) {
        m_canvas->setTabletDevice(static_cast<QTabletEvent *>(event));
        return true;
    }
    return QApplication::event(event);
}

Utilizamos esta función para gestionar los eventos « TabletEnterProximity » y « TabletLeaveProximity », que se generan cuando una herramienta de dibujo se acerca o se aleja de la tableta. Aquí llamamos a ` TabletCanvas::setTabletDevice()`, que a su vez llama a ` updateCursor()`, lo cual establecerá un cursor adecuado. Esta es la única razón por la que necesitamos los eventos de proximidad; para que el dibujo sea correcto, basta con que ` TabletCanvas ` observe los métodos ` device()` y ` pointerType()` en cada evento que reciba.

La función ` main() `

A continuación se muestra la función main() del ejemplo:

int main(int argv, char *args[])
{
    TabletApplication app(argv, args);
    TabletCanvas *canvas = new TabletCanvas;
    app.setCanvas(canvas);

    MainWindow mainWindow(canvas);
    mainWindow.resize(500, 500);
    mainWindow.show();
    return app.exec();
}

Aquí creamos un « MainWindow » y lo mostramos como una ventana de nivel superior. Utilizamos la clase « TabletApplication ». Debemos configurar el lienzo una vez creada la aplicación. No podemos utilizar clases que implementen la gestión de eventos antes de que se haya instanciado un objeto « QApplication ».

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.