Back to Qt.io
Contact Us Blog Download Qt

タブレットの例

この例では、Qt アプリケーションでワコムタブレットを使用する方法を示します。

Qt アプリケーションでタブレットを使用すると、QTabletEventが生成されます。タブレットのイベントを処理したい場合は、tabletEvent （）イベントハンドラを再実装する必要があります。イベントは、描画に使用するツール（スタイラス）がタブレットの近くに入ったり離れたりしたとき（つまり、タブレットを閉じているが、タブレットを押し下げていないとき）、ツールを押し下げたり離したりしたとき、ツールがタブレット上を移動したとき、ツールのボタンが押されたり離されたりしたときに生成されます。

QTabletEvent で利用可能な情報は、使用するデバイスによって異なります。この例では、最大3つの異なる描画ツール（スタイラス、エアブラシ、アートペン）を持つタブレットを扱うことができます。これらのいずれについても、イベントにはツールの位置、タブレットの筆圧、ボタンの状態、垂直チルト、水平チルト（タブレットのハードウェアが提供できる場合、デバイスとタブレットの垂直の間の角度）が含まれます。エアブラシにはフィンガーホイールがあり、この位置もタブレットイベントで確認できます。アートペンは、タブレットの表面に垂直な軸を中心に回転します。

この例では、描画プログラムを実装します。紙に鉛筆で描くように、スタイラスを使ってタブレットに描くことができます。エアブラシで描くと、仮想の絵の具が噴射され、フィンガーホイールで噴射の濃度を変えることができます。アートペンで描くと、ペンの回転によって幅と終点の角度が変わる線が描かれます。筆圧と傾きは、色のアルファ値と彩度、ストロークの幅を変更するために割り当てることもできます。

この例は次のように構成されている：

  • MainWindow クラスはQMainWindow を継承し、メニューを作成し、それらのスロットとシグナルを接続する。
  • TabletCanvas クラスはQWidget を継承し、タブレット・イベントを受け取ります。イベントを使用して画面外のピクセ ルマップにペイントし、それをレンダリングします。
  • TabletApplication クラスはQApplication を継承しています。このクラスはタブレット近接イベントを処理します。
  • main() 関数はMainWindow を作成し、トップレベル・ウィンドウとして表示します。

MainWindow クラスの定義

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() の冒頭で、Fileメニューを入力します。Qt 5.6 で導入されたaddAction() のオーバーロードを使用して、ショートカット（およびオプションでアイコン）を持つメニュー項目を作成し、メニューに追加し、スロットに接続します。これらの一般的なメニュー・アイテムのプラットフォーム固有の標準キー・ショートカットを取得するには、QKeySequence を使用します。

また、ブラシメニューにも入力します。ブラシを変更するコマンドには通常標準ショートカットがないので、tr （）を使って、アプリケーションの言語翻訳と一緒にショートカットを翻訳できるようにします。

ここでは、タブレットメニューのサブメニューに、相互に排他的なアクションのグループを作成し、各QTabletEvent のどのプロパティを使用して、描画される線やエアブラシされる色の半透明度（アルファチャンネル）を変化させるかを選択します。

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

タブレットの圧力、傾き、またはエアブラシツールのサムホイールの位置によって、描画色のアルファ成分を変化させるかどうかをユーザーが選択できるようにします。それぞれの選択に対して1つのアクションを用意し、さらにアルファを変更しない、つまり色を不透明に保つことを選択するアクションを用意しました。アクションはチェック可能にしてある。alphaChannelGroup 、常に1つのアクションだけがチェックされるようにする。アクションがチェックされると、triggered() シグナルがグループから発信されるので、それをMainWindow::setAlphaValuator() に接続する。QTabletEvent のどのプロパティ（valuator）にこれから注目すべきかを知る必要があるので、QAction::data プロパティを使ってこの情報を渡す。(これを可能にするためには、QVariant に挿入できるように、列挙型Valuator が登録されたメタタイプでなければなりません。これは、tabletcanvas.h のQ_ENUM 宣言によって実現されます)。

以下は、setAlphaValuator() の実装です：

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

QAction::data() からValuator enum を取得し、それをTabletCanvas::setAlphaChannelValuator() に渡すだけである。もしdata プロパティを使用しないのであれば、switch 文などでQAction ポインタ自体を比較する必要がある。しかし、そうすると、比較のために各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;
};

キャンバスは、アルファ・チャンネル、彩度、ストロークの線幅を変更できます。これらを変更できるQTabletEvent プロパティを列挙した列挙型があります。それぞれにプライベート変数を用意しています：m_alphaChannelValuator m_colorSaturationValuator とm_lineWidthValuator があり、それに対するアクセサ関数が用意されています。

m_pen を使ってQPixmap に描画し、m_color を使ってm_brush に描画する。QTabletEvent を受け取るたびに、ストロークはlastPoint から現在のQTabletEvent で指定されたポイントに描画され、次回のために位置と回転がlastPoint に保存されます。saveImage() とloadImage() 関数は、QPixmap をディスクに保存し、ロードします。pixmap は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;
}

file から画像をロードするload() を呼び出すだけです。

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

この関数には3種類のイベントが発生します：TabletPress TabletRelease 、TabletMove 。描画ツールがタブレット上で押し下げられたり、タブレットから持ち上げられたり、タブレット上を移動したりしたときに発生します。デバイスがタブレット上で押し下げられたとき、m_deviceDown をtrue に設定します。これにより、移動イベントを受信したときに描画する必要があることがわかります。ユーザーがどのタブレット・イベント・プロパティに注目するかによって、m_brush とm_pen を更新するように、updateBrush() を実装しました。updateCursor() 関数は、使用中の描画ツールを表すカーソルを選択し、タブレットの近くでツールをホバーすると、どのようなストロークを描こうとしているかがわかるようにします。

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) が使用されている場合、TabletMove イベントごとにupdateCursor() も呼び出され、ペン先の角度がわかるように回転したカーソルがレンダリングされます。

以下は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 を返します。どの画面にレンダリングするかがわかったので、適切な解像度の pixmap を作成できます。この例ではズームをサポートしていないので、ウィンドウを埋めるpixmapのサイズは画面の解像度に依存する。デフォルトは灰色なので、背景も描画する必要がある。

その後、ウィジェットの左上にpixmapを描画します。

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

この関数では、ツールの動きに応じてpixmapに描画する。タブレットで使われているツールがスタイラスの場合、最後に認識された位置から現在の位置まで線を引きたい。また、これが未知のデバイスに対する妥当な処理であると仮定するが、ステータスバーを警告で更新する。エアブラシの場合、ソフトグラデーションで塗りつぶされた円を描きたい。デフォルトでは、エアブラシ上のフィンガーホイールの位置である接線方向の圧力に依存します。ツールが回転スタイラスの場合、台形のストロークセグメントを描くことでフェルトマーカーをシミュレートします。

        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 までの数値で設定します。すなわち、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は不透明である。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);
    }
}

最後に、ポインタがスタイラスか消しゴムかをチェックする。もし消しゴムであれば、色をpixmapの背景色に設定し、筆圧でペンの幅を決めます。

TabletApplicationクラスの定義

event() 関数を再実装したいので、このクラスではQApplication を継承している。

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 TabletEnterProximity と イベントは オブジェクトに送られ、その他のタブレット・イベントは の ハンドラに送られ、 () に送られます。TabletLeaveProximity QApplication QWidget event() tabletEvent

TabletApplication クラスの実装

以下は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. 本書に含まれるドキュメントの著作権は、それぞれの所有者に帰属します。 本書で提供されるドキュメントは、Free Software Foundation が発行したGNU Free Documentation License version 1.3に基づいてライセンスされています。 Qtおよびそれぞれのロゴは、フィンランドおよびその他の国におけるThe Qt Company Ltd.の 商標です。その他すべての商標は、それぞれの所有者に帰属します。