Plug & Paint Example

The MainWindow Class

The MainWindow class is a standard QMainWindow subclass, as found in many of the other examples (e.g., Application). Here, we'll concentrate on the parts of the code that are related to plugins.

    void MainWindow::loadPlugins()
    {
        pluginsDir = QDir(qApp->applicationDirPath());

    #if defined(Q_OS_WIN)
        if (pluginsDir.dirName().toLower() == "debug" || pluginsDir.dirName().toLower() == "release")
            pluginsDir.cdUp();
    #elif defined(Q_OS_MAC)
        if (pluginsDir.dirName() == "MacOS") {
            pluginsDir.cdUp();
            pluginsDir.cdUp();
            pluginsDir.cdUp();
        }
    #endif
        pluginsDir.cd("plugins");

The loadPlugins() function is called from the MainWindow constructor to detect plugins and update the Brush, Shapes, and Filters menus. We start by initializing the pluginsDir member variable to refer to the plugins directory of the Plug & Paint example. On Unix, this is just a matter of initializing the QDir variable with QApplication::applicationDirPath(), the path of the executable file, and to do a cd(). On Windows and Mac OS X, this file is usually located in a subdirectory, so we need to take this into account.

        foreach (QString fileName, pluginsDir.entryList(QDir::Files)) {
            QPluginLoader loader(pluginsDir.absoluteFilePath(fileName));
            QObject *plugin = loader.instance();
            if (plugin) {
                BrushInterface *iBrush = qobject_cast<BrushInterface *>(plugin);
                if (iBrush)
                    addToMenu(plugin, iBrush->brushes(), brushMenu,
                              SLOT(changeBrush()), brushActionGroup);

                ShapeInterface *iShape = qobject_cast<ShapeInterface *>(plugin);
                if (iShape)
                    addToMenu(plugin, iShape->shapes(), shapesMenu,
                              SLOT(insertShape()));

                FilterInterface *iFilter = qobject_cast<FilterInterface *>(plugin);
                if (iFilter)
                    addToMenu(plugin, iFilter->filters(), filterMenu,
                              SLOT(applyFilter()));

                pluginFileNames += fileName;
            }
        }

We use QDir::entryList() to get a list of all files in that directory. Then we iterate over the result using foreach and try to load the plugin using QPluginLoader.

To the application that loads the plugin, a Qt plugin is simply a QObject. That QObject may implement extra interfaces using multiple inheritance. The object is accessible through QPluginLoader::instance(). If the dynamic library isn't a Qt plugin, or if it was compiled against an incompatible version of the Qt library, QPluginLoader::instance() returns a null pointer.

If QPluginLoader::instance() is non-null, we check which interfaces it implements using qobject_cast(). First, we try to cast the plugin instance to a BrushInterface; if it works, we call the private function addToMenu() with the list of brushes returned by brushes(). Then we do the same with the ShapeInterface and the FilterInterface.

        brushMenu->setEnabled(!brushActionGroup->actions().isEmpty());
        shapesMenu->setEnabled(!shapesMenu->actions().isEmpty());
        filterMenu->setEnabled(!filterMenu->actions().isEmpty());
    }

At the end, we enable or disable the Brush, Shapes, and Filters menus based on whether they contain any items.

    void MainWindow::aboutPlugins()
    {
        PluginDialog dialog(pluginsDir.path(), pluginFileNames, this);
        dialog.exec();
    }

The aboutPlugins() slot is called on startup and can be invoked at any time through the About Plugins action. It pops up a PluginDialog, providing information about the loaded plugins.

The addToMenu() function is called from loadPlugin() to create QActions for custom brushes, shapes, or filters and add them to the relevant menu. The QAction is created with the plugin from which it comes from as the parent; this makes it convenient to get access to the plugin later.

    void MainWindow::changeBrush()
    {
        QAction *action = qobject_cast<QAction *>(sender());
        BrushInterface *iBrush = qobject_cast<BrushInterface *>(action->parent());
        QString brush = action->text();

        paintArea->setBrush(iBrush, brush);
    }

The changeBrush() slot is invoked when the user chooses one of the brushes from the Brush menu. We start by finding out which action invoked the slot using QObject::sender(). Then we get the BrushInterface out of the plugin (which we conveniently passed as the QAction's parent) and we call PaintArea::setBrush() with the BrushInterface and the string identifying the brush. Next time the user draws on the paint area, PaintArea will use this brush.

    void MainWindow::insertShape()
    {
        QAction *action = qobject_cast<QAction *>(sender());
        ShapeInterface *iShape = qobject_cast<ShapeInterface *>(action->parent());

        QPainterPath path = iShape->generateShape(action->text(), this);
        if (!path.isEmpty())
            paintArea->insertShape(path);
    }

The insertShape() is invoked when the use chooses one of the shapes from the Shapes menu. We retrieve the QAction that invoked the slot, then the ShapeInterface associated with that QAction, and finally we call ShapeInterface::generateShape() to obtain a QPainterPath.

    void MainWindow::applyFilter()
    {
        QAction *action = qobject_cast<QAction *>(sender());
        FilterInterface *iFilter =
                qobject_cast<FilterInterface *>(action->parent());

        QImage image = iFilter->filterImage(action->text(), paintArea->image(),
                                            this);
        paintArea->setImage(image);
    }

The applyFilter() slot is similar: We retrieve the QAction that invoked the slot, then the FilterInterface associated to that QAction, and finally we call FilterInterface::filterImage() to apply the filter onto the current image.

    void PaintArea::setBrush(BrushInterface *brushInterface, const QString &brush)
    {
        this->brushInterface = brushInterface;
        this->brush = brush;
    }

    void PaintArea::mouseMoveEvent(QMouseEvent *event)
    {
        if ((event->buttons() & Qt::LeftButton) && lastPos != QPoint(-1, -1)) {
            if (brushInterface) {
                QPainter painter(&theImage);
                setupPainter(painter);
                QRect rect = brushInterface->mouseMove(brush, painter, lastPos,
                                                       event->pos());
                update(rect);
            }

            lastPos = event->pos();
        }
    }

    void PluginDialog::populateTreeWidget(const QString &path,
                                          const QStringList &fileNames)
    {
        if (fileNames.isEmpty()) {
            label->setText(tr("Plug & Paint couldn't find any plugins in the %1 "
                              "directory.")
                           .arg(QDir::convertSeparators(path)));
            treeWidget->hide();
        } else {
            label->setText(tr("Plug & Paint found the following plugins in the %1 "
                              "directory:")
                           .arg(QDir::convertSeparators(path)));

            QDir dir(path);

            foreach (QString fileName, fileNames) {
                QPluginLoader loader(dir.absoluteFilePath(fileName));
                QObject *plugin = loader.instance();

                QTreeWidgetItem *pluginItem = new QTreeWidgetItem(treeWidget);
                pluginItem->setText(0, fileName);
                treeWidget->setItemExpanded(pluginItem, true);

                QFont boldFont = pluginItem->font(0);
                boldFont.setBold(true);
                pluginItem->setFont(0, boldFont);

                if (plugin) {
                    BrushInterface *iBrush = qobject_cast<BrushInterface *>(plugin);
                    if (iBrush)
                        addItems(pluginItem, "BrushInterface", iBrush->brushes());

                    ShapeInterface *iShape = qobject_cast<ShapeInterface *>(plugin);
                    if (iShape)
                        addItems(pluginItem, "ShapeInterface", iShape->shapes());

                    FilterInterface *iFilter =
                            qobject_cast<FilterInterface *>(plugin);
                    if (iFilter)
                        addItems(pluginItem, "FilterInterface", iFilter->filters());
                }
            }
        }
    }