平板示例

此示例显示如何在 Qt 应用程序中使用 Wacom 平板。

当您使用 Qt 应用程序中的平板时，会生成 QTabletEvent 事件。如果想要处理平板事件，则需要重新实现 tabletEvent() 事件处理器。当用于绘图的工具（触控笔）进入和离开平板附近时（即，当它关闭但未按下时）、当工具被按下和释放时、当工具在平板上移动时以及当工具上的某个按钮被按下或释放时，都会生成事件。

QTabletEvent 中可用的信息取决于所使用的设备。此示例可以处理具有多达三种不同绘图工具的平板：触控笔、喷笔和艺术笔。对于这些工具中的任何一种，事件将包含工具的位置、平板的压力、按钮状态、垂直倾斜和水平倾斜（即设备与平板垂直线的夹角，如果平板硬件可以提供该信息）。喷笔有手指轮；该位置的信息也在平板事件中提供。艺术笔提供绕与平板表面垂直的轴的旋转，因此它可以用于书法。

在此示例中，我们实现了一个绘图程序。您可以使用触控笔在平板上绘制，就像您在纸上使用铅笔一样。当您使用喷笔绘制时，您将得到虚拟油漆的喷雾；手指轮用于更改喷雾的密度。当您使用艺术笔绘制时，您将得到一条线，其宽度和端点角度取决于笔的旋转。压力和倾斜也可以用于改变颜色的alpha和饱和度值以及笔触的宽度。

此示例包括以下内容

  • 主窗口类继承自 QMainWindow，创建了菜单，并连接了它们的槽和信号。
  • TabletCanvas 类继承自 QWidget，接收平板事件。它使用事件在离屏位图中绘制，然后渲染它。
  • TabletApplication 类继承自 QApplication。此类用于处理平板靠近事件。
  • 主函数创建了 MainWindow 并将其显示为顶级窗口。

主窗口类定义

主窗口创建了一个 TabletCanvas 并将其设置为其中的中心小部件。

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() 函数设置了包含操作的菜单。我们有一个专门用于改变透明度通道、颜色饱和度和线条宽度的 QActionGroup。这些动作组连接到 setAlphaValuator()、setSaturationValuator() 和 setLineWidthValuator() 插槽，这些插槽调用 TabletCanvas 中的函数。

MainWindow 类实现

我们从查看构造函数 MainWindow() 开始。

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

在构造函数中，我们调用 createMenus() 以创建所有动作和菜单，并将画布设置为中心小部件。

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);

createMenus() 的开始，我们填充 文件 菜单。我们使用在 Qt 5.6 中引入的 addAction() 的重载版本来创建一个带有快捷键（和可选图标）的菜单项，将其添加到其菜单，并将其连接到槽，所有这些都在一行代码中完成。我们使用 QKeySequence 来获取这些常用菜单项的平台特定标准快捷键。

我们还填充了 画笔 菜单。通常，更改画笔的命令没有标准快捷键，所以我们使用 tr() 使快捷键与应用程序的语言翻译一起进行翻译。

现在，我们将查看在 平板 菜单的子菜单中创建的一组互斥动作，用于选择将使用哪个 QTabletEvent 属性来改变绘制线条或喷涂颜色的透明度（alpha 通道）。

    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);

我们希望用户能够选择是否将绘制颜色的alpha组件由平板的压力、倾斜或气刷工具的拇指轮位置调制。我们对每个选择都有一个动作，还有一个额外的动作来选择不要修改alpha，即保持颜色不透明。我们使动作可复选；然后 alphaChannelGroup 将确保在任何时候只有一个动作被选中。当有一个动作被选中时，该组会发出 triggered() 信号，因此我们将其连接到 MainWindow::setAlphaValuator()。它需要知道现在要注意 QTabletEvent 的哪个属性（数值选择器），所以我们使用 QAction::data 属性来传递这些信息。（为了实现这一点，枚举 Valuator 必须是一个已注册的元类型，以便它可以插入到 QVariant 中。这是通过 tabletcanvas.h 中的 Q_ENUM 声明完成的。）

以下是 setAlphaValuator() 的实现。

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

它只需要从 QAction::data() 中检索 Valuator 枚举，并将其传递给 TabletCanvas::setAlphaChannelValuator()。如果我们不使用 data 属性，我们则需要比较 QAction 指针本身，例如在 switch 语句中。但那样就需要将每个 QAction 的指针存储在类变量中，用于比较目的。

以下是 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);
}

我们在用户首次从菜单或操作快捷键选择 画笔颜色... 时进行懒初始化 QColorDialog。当对话框打开时，每次用户选择不同的颜色，都会调用 TabletCanvas::setColor() 来更改绘制颜色。因为它是一个非模态对话框，所以用户可以自由地保持颜色对话框打开，以便可以方便地频繁更改颜色，或者关闭它并在以后重新打开。

以下是 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;
}

我们使用QFileDialog让用户选择保存绘图的文件，然后调用TabletCanvas::saveImage()将其实际写入文件。

以下是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");
}

我们使用QFileDialog让用户选择要打开的图像文件；然后使用loadImage()请求画布加载图像。

以下是about()的实现。

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

我们显示一个消息框，其中包含示例的简短描述。

TabletCanvas 类定义

TabletCanvas类提供了一个用户可以在上面用平板电脑绘图的表面。

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;
};

画布可以改变画笔的alpha通道、颜色饱和度和线宽。我们有一个枚举，列出了可以用来调谐这些属性的可能使用的QTabletEvent属性。我们为每个属性保持一个私有变量：m_alphaChannelValuator、m_colorSaturationValuator和m_lineWidthValuator，并提供访问器函数。

我们使用m_pen和m_brush在QPixmap上绘制，使用m_color。每当收到一个QTabletEvent时，都会从lastPoint绘制到当前QTabletEvent给出的点，然后保存位置和旋转到lastPoint以供下次使用。函数saveImage()和loadImage()将保存和加载QPixmap到磁盘。在paintEvent()中绘制位数组。

平板事件在tabletEvent()中解释，而paintPixmap()、updateBrush()和updateCursor()是tabletEvent()使用的辅助函数。

TabletCanvas 类实现

让我们从构造函数开始看看。

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);
}

在构造函数中，我们初始化了我们所有大类的变量。

以下是saveImage()的实现。

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

QPixmap实现了保存自身到磁盘的功能，所以我们可以简单地调用save()。

以下是loadImage()的实现。

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

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

我们简单地调用load()，它从file加载图像。

以下是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();
}

我们在这个函数中得到三种类型的事件：TabletPress、TabletRelease和TabletMove，它们在绘图工具按下、抬起或平板上移动时产生。当一个设备在平板上按下时，我们设置m_deviceDown为true；然后我们知道当收到移动事件时应绘制。我们已经实现了updateBrush()，根据用户选择的关注哪些平板事件属性来更新m_brush和m_pen。函数updateCursor()选择一个光标来表示正在使用的绘图工具，这样你可以ComboBox使用工具在平板附近的鼠标悬停时看到将要绘制的线条类型。

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);
}

如果使用艺术笔（RotationStylus），updateCursor()也会针对每个TabletMove事件调用，并渲染一个旋转光标，以便你可以看到笔尖的角度。

这里是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);
}

Qt第一次调用paintEvent()时，m_pixmap是默认构造的，所以QPixmap::isNull()返回true。现在我们知道我们将渲染到哪个屏幕，我们可以根据适当的分辨率创建一个位图。用位图填充窗口的大小取决于屏幕分辨率；示例不支持缩放；可能一个屏幕是高DPI，而另一个不是。我们还需要绘制背景，因为默认背景是灰色。

之后，我们只需要将位图绘制到小部件的左上角。

这里是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 radius = grad.radius();
                painter.drawEllipse(event->position(), radius, radius);
                update(QRect(event->position().toPoint() - QPoint(radius, radius), QSize(radius * 2, radius * 2)));
            }
            break;
        case QInputDevice::DeviceType::Puck:
        case QInputDevice::DeviceType::Mouse:
            {
                const QString error(tr("This input device is not supported by the example."));
#if QT_CONFIG(statustip)
                QStatusTipEvent status(error);
                QCoreApplication::sendEvent(this, &status);
#else
                qWarning() << error;
#endif
            }
            break;
        default:
            {
                const QString error(tr("Unknown tablet device - treating as stylus"));
#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;
    }
}

在这个函数中，我们根据工具的运动在位图上绘制。如果平板电脑上使用的工具是笔尖，我们希望从最后已知位置绘制到当前位置的线条。我们也假设这是对任何未知设备的合理处理方式，但同时在状态栏中更新警告。如果是一个喷枪，我们想要绘制一个填充着柔和渐变的圆圈，其密度可以依赖于各种事件参数。默认情况下，它依赖于切向压力，即喷枪上手指轮的位置。如果工具是旋转笔尖，我们通过绘制梯形描边段来模拟毛笔。

        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;

在updateBrush()中，我们将用于绘制的笔和刷设置为与m_alphaChannelValuator、m_lineWidthValuator、m_colorSaturationValuator和m_color匹配。我们将会检查这些变量的每个代码以设置m_brush和m_pen。

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);

我们获取当前绘图颜色的色调、饱和度、值和α值。hValue和vValue被设置为从0到255的数字，原始值是-60到60度的角度，即0等于-60，127等于0，255等于60度。测量的角度是在设备与平板电脑垂线之间（见QTabletEvent中的插图）。

    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);
    }

QColor的α通道作为一个介于0到255的数字给出，其中0是透明的，255是不透明的；或者作为一个介于0到1.0的浮点数，其中0是透明的，1.0是不透明的。pressure()返回介于0.0到1.0之间的qreal。当笔垂直于平板电脑时，我们得到最小的α值（即颜色最透明）。我们选择垂直和水平倾斜值中的最大值。

    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:
            ;
    }

在HSV颜色模型中，颜色饱和度可以是一位介于0到255之间的整数或介于0到1之间的浮点值。我们选择将α表示为整数，因此我们使用整数值调用setHsv()。这意味着我们需要将压力乘到一个介于0到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);
    }

如果选择，笔划宽度可以随着压力增加。但是当笔宽由倾斜控制时，我们让宽度随着工具与平板电脑垂线之间的角度增加。

    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);
    }
}

最后，我们检查指针是不是笔尖或橡皮擦。如果是橡皮擦，我们将颜色设置为位图的背景色，并让压力决定笔的宽度；否则，我们在函数中设置之前决定的颜色。

TabletApplication类定义

我们在这个类中继承了 QApplication，因为我们想重新实现 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 作为 QApplication 的子类，以便接收平板电脑接近事件并将它们转发到 TabletCanvas。当有其他平板电脑事件发送到 QWidget 的 event() 处理器时，它会将这些事件发送到 tabletEvent()，而 TabletEnterProximity 和 TabletLeaveProximity 事件则发送到 QApplication 对象。

平板电脑应用类实现

这是对 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);
}

我们使用此函数来处理 TabletEnterProximity 和 TabletLeaveProximity 事件，这些事件在有绘图工具进入或离开平板电脑附近时生成。在这里我们调用 TabletCanvas::setTabletDevice()，然后它会调用 updateCursor()，这将设置一个适当的指针光标。我们之所以需要接近事件，唯一的原因是；为了正确绘图，对于 TabletCanvas 来说，观察到每个它接收的事件中的 device() 和 pointerType() 已经足够了。

main() 函数

以下是示例的 main() 函数

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();
}

在这里我们创建了一个 MainWindow 并将其显示为一个顶级窗口。我们使用 TabletApplication 类。我们必须在创建应用程序后设置画布。我们不能在构建了 QApplication 对象之前使用实现事件处理的类。

示例项目 @ code.qt.io

© 2024 The Qt Company Ltd. 本文档中的文档贡献属于其各自的所有者。本处提供的文档受到由自由软件基金会发布的 GNU自由文档许可证版本1.3 的条款约束。Qt及相关的商标为The Qt Company Ltd.在芬兰或其他国家的商标。其他所有商标均为其各自所有者的财产。