Plug & Paint Basic Tools Example

Implementation of the Brush Interface

Let's now review the implementation of the BasicToolsPlugin member functions inherited from BrushInterface.

    QStringList BasicToolsPlugin::brushes() const
    {
        return QStringList() << tr("Pencil") << tr("Air Brush")
                             << tr("Random Letters");
    }

The brushes() function returns a list of brushes provided by this plugin. We provide three brushes: Pencil, Air Brush, and Random Letters.

    QRect BasicToolsPlugin::mousePress(const QString &brush, QPainter &painter,
                                       const QPoint &pos)
    {
        return mouseMove(brush, painter, pos, pos);
    }

On a mouse press event, we just call mouseMove() to draw the spot where the event occurred.

    QRect BasicToolsPlugin::mouseMove(const QString &brush, QPainter &painter,
                                      const QPoint &oldPos, const QPoint &newPos)
    {
        painter.save();

        int rad = painter.pen().width() / 2;
        QRect boundingRect = QRect(oldPos, newPos).normalized()
                                                  .adjusted(-rad, -rad, +rad, +rad);
        QColor color = painter.pen().color();
        int thickness = painter.pen().width();
        QColor transparentColor(color.red(), color.green(), color.blue(), 0);

In mouseMove(), we start by saving the state of the QPainter and we compute a few variables that we'll need later.

        if (brush == tr("Pencil")) {
            painter.drawLine(oldPos, newPos);
        } else if (brush == tr("Air Brush")) {
            int numSteps = 2 + (newPos - oldPos).manhattanLength() / 2;

            painter.setBrush(QBrush(color, Qt::Dense6Pattern));
            painter.setPen(Qt::NoPen);

            for (int i = 0; i < numSteps; ++i) {
                int x = oldPos.x() + i * (newPos.x() - oldPos.x()) / (numSteps - 1);
                int y = oldPos.y() + i * (newPos.y() - oldPos.y()) / (numSteps - 1);

                painter.drawEllipse(x - (thickness / 2), y - (thickness / 2),
                                    thickness, thickness);
            }
        } else if (brush == tr("Random Letters")) {
            QChar ch('A' + (rand() % 26));

            QFont biggerFont = painter.font();
            biggerFont.setBold(true);
            biggerFont.setPointSize(biggerFont.pointSize() + thickness);
            painter.setFont(biggerFont);

            painter.drawText(newPos, QString(ch));

            QFontMetrics metrics(painter.font());
            boundingRect = metrics.boundingRect(ch);
            boundingRect.translate(newPos);
            boundingRect.adjust(-10, -10, +10, +10);
        }
        painter.restore();
        return boundingRect;
    }

Then comes the brush-dependent part of the code:

• If the brush is Pencil, we just call QPainter::drawLine() with the current QPen.
• If the brush is Air Brush, we start by setting the painter's QBrush to Qt::Dense6Pattern to obtain a dotted pattern. Then we draw a circle filled with that QBrush several times, resulting in a thick line.
• If the brush is Random Letters, we draw a random letter at the new cursor position. Most of the code is for setting the font to be bold and larger than the default font and for computing an appropriate bounding rect.

At the end, we restore the painter state to what it was upon entering the function and we return the bounding rectangle.

    QRect BasicToolsPlugin::mouseRelease(const QString & /* brush */,
                                         QPainter & /* painter */,
                                         const QPoint & /* pos */)
    {
        return QRect(0, 0, 0, 0);
    }

When the user releases the mouse, we do nothing and return an empty QRect.

    QStringList BasicToolsPlugin::shapes() const
    {
        return QStringList() << tr("Circle") << tr("Star") << tr("Text...");
    }

    QPainterPath BasicToolsPlugin::generateShape(const QString &shape,
                                                 QWidget *parent)
    {
        QPainterPath path;

        if (shape == tr("Circle")) {
            path.addEllipse(0, 0, 50, 50);
        } else if (shape == tr("Star")) {
            path.moveTo(90, 50);
            for (int i = 1; i < 5; ++i) {
                path.lineTo(50 + 40 * cos(0.8 * i * Pi),
                            50 + 40 * sin(0.8 * i * Pi));
            }
            path.closeSubpath();
        } else if (shape == tr("Text...")) {
            QString text = QInputDialog::getText(parent, tr("Text Shape"),
                                                 tr("Enter text:"),
                                                 QLineEdit::Normal, tr("Qt"));
            if (!text.isEmpty()) {
                QFont timesFont("Times", 50);
                timesFont.setStyleStrategy(QFont::ForceOutline);
                path.addText(0, 0, timesFont, text);
            }
        }

        return path;
    }

    QStringList BasicToolsPlugin::filters() const
    {
        return QStringList() << tr("Invert Pixels") << tr("Swap RGB")
                             << tr("Grayscale");
    }

    QImage BasicToolsPlugin::filterImage(const QString &filter, const QImage &image,
                                         QWidget * /* parent */)
    {
        QImage result = image.convertToFormat(QImage::Format_RGB32);

        if (filter == tr("Invert Pixels")) {
            result.invertPixels();
        } else if (filter == tr("Swap RGB")) {
            result = result.rgbSwapped();
        } else if (filter == tr("Grayscale")) {
            for (int y = 0; y < result.height(); ++y) {
                for (int x = 0; x < result.width(); ++x) {
                    int pixel = result.pixel(x, y);
                    int gray = qGray(pixel);
                    int alpha = qAlpha(pixel);
                    result.setPixel(x, y, qRgba(gray, gray, gray, alpha));
                }
            }
        }
        return result;
    }

    Q_EXPORT_PLUGIN2(pnp_basictools, BasicToolsPlugin)

    TEMPLATE      = lib
    CONFIG       += plugin
    INCLUDEPATH  += ../..
    HEADERS       = basictoolsplugin.h
    SOURCES       = basictoolsplugin.cpp
    TARGET        = pnp_basictools
    DESTDIR       = ../../plugandpaint/plugins

    contains(TEMPLATE,lib) {
       CONFIG(debug, debug|release) {
          unix:TARGET = $$member(TARGET, 0)_debug
          else:TARGET = $$member(TARGET, 0)d
       }
    }