|  | Home · All Classes · Main Classes · Annotated · Grouped Classes · Functions |

# mainwindow.cpp Example File
tools/plugandpaint/mainwindow.cpp

        /****************************************************************************
        **
        ** Copyright (C) 2005-2005 Trolltech AS. All rights reserved.
        **
        ** This file is part of the documentation of the Qt Toolkit.
        **
        ** This file may be distributed under the terms of the Q Public License
    ** as defined by Trolltech AS of Norway and appearing in the file
    ** LICENSE.QPL included in the packaging of this file.
    **
    ** This file may be distributed and/or modified under the terms of the
    ** GNU General Public License version 2 as published by the Free Software
    ** Foundation and appearing in the file LICENSE.GPL included in the
    ** packaging of this file.
    **
    ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
    **   information about Qt Commercial License Agreements.
    ** See http://www.trolltech.com/qpl/ for QPL licensing information.
    ** See http://www.trolltech.com/gpl/ for GPL licensing information.
    **
    ** Contact info@trolltech.com if any conditions of this licensing are
    ** not clear to you.
        **
        ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
        ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        **
        ****************************************************************************/

        #include <QtGui>

        #include "interfaces.h"
        #include "mainwindow.h"
        #include "paintarea.h"
        #include "plugindialog.h"

        MainWindow::MainWindow()
        {
            paintArea = new PaintArea;

            scrollArea = new QScrollArea;
            scrollArea->setBackgroundRole(QPalette::Dark);
            scrollArea->setWidget(paintArea);
            setCentralWidget(scrollArea);

            createActions();
            createMenus();
            loadPlugins();

            setWindowTitle(tr("Plug & Paint"));

            if (!brushActionGroup->actions().isEmpty())
                brushActionGroup->actions().first()->trigger();

            QTimer::singleShot(500, this, SLOT(aboutPlugins()));
        }

        void MainWindow::open()
        {
            QString fileName = QFileDialog::getOpenFileName(this,
                                            tr("Open File"), QDir::currentPath());
            if (!fileName.isEmpty()) {
                if (!paintArea->openImage(fileName)) {
                    QMessageBox::information(this, tr("Plug & Paint"),
                                             tr("Cannot load %1.").arg(fileName));
                    return;
                }
                paintArea->adjustSize();
            }
        }

        bool MainWindow::saveAs()
        {
            QString initialPath = QDir::currentPath() + "/untitled.png";

            QString fileName = QFileDialog::getSaveFileName(this, tr("Save As"),
                                                            initialPath);
            if (fileName.isEmpty()) {
                return false;
            } else {
                return paintArea->saveImage(fileName, "png");
            }
        }

        void MainWindow::brushColor()
        {
            QColor newColor = QColorDialog::getColor(paintArea->brushColor());
            if (newColor.isValid())
                paintArea->setBrushColor(newColor);
        }

        void MainWindow::brushWidth()
        {
            bool ok;
            int newWidth = QInputDialog::getInteger(this, tr("Plug & Paint"),
                                                    tr("Select brush width:"),
                                                    paintArea->brushWidth(),
                                                    1, 50, 1, &ok);
            if (ok)
                paintArea->setBrushWidth(newWidth);
        }

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

            paintArea->setBrush(iBrush, 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);
        }

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

        void MainWindow::about()
        {
           QMessageBox::about(this, tr("About Plug & Paint"),
                    tr("The <b>Plug & Paint</b> example demonstrates how to write Qt "
                       "applications that can be extended through plugins."));
        }

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

        void MainWindow::createActions()
        {
            openAct = new QAction(tr("&Open..."), this);
            openAct->setShortcut(tr("Ctrl+O"));
            connect(openAct, SIGNAL(triggered()), this, SLOT(open()));

            saveAsAct = new QAction(tr("&Save As..."), this);
            saveAsAct->setShortcut(tr("Ctrl+S"));
            connect(saveAsAct, SIGNAL(triggered()), this, SLOT(saveAs()));

            exitAct = new QAction(tr("E&xit"), this);
            exitAct->setShortcut(tr("Ctrl+Q"));
            connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));

            brushColorAct = new QAction(tr("&Brush Color..."), this);
            connect(brushColorAct, SIGNAL(triggered()), this, SLOT(brushColor()));

            brushWidthAct = new QAction(tr("&Brush Width..."), this);
            connect(brushWidthAct, SIGNAL(triggered()), this, SLOT(brushWidth()));

            brushActionGroup = new QActionGroup(this);

            aboutAct = new QAction(tr("&About"), this);
            connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));

            aboutQtAct = new QAction(tr("About &Qt"), this);
            connect(aboutQtAct, SIGNAL(triggered()), qApp, SLOT(aboutQt()));

            aboutPluginsAct = new QAction(tr("About &Plugins"), this);
            connect(aboutPluginsAct, SIGNAL(triggered()), this, SLOT(aboutPlugins()));
        }

        void MainWindow::createMenus()
        {
            fileMenu = menuBar()->addMenu(tr("&File"));
            fileMenu->addAction(openAct);
            fileMenu->addAction(saveAsAct);
            fileMenu->addSeparator();
            fileMenu->addAction(exitAct);

            brushMenu = menuBar()->addMenu(tr("&Brush"));
            brushMenu->addAction(brushColorAct);
            brushMenu->addAction(brushWidthAct);
            brushMenu->addSeparator();

            shapesMenu = menuBar()->addMenu(tr("&Shapes"));

            filterMenu = menuBar()->addMenu(tr("&Filter"));

            menuBar()->addSeparator();

            helpMenu = menuBar()->addMenu(tr("&Help"));
            helpMenu->addAction(aboutAct);
            helpMenu->addAction(aboutQtAct);
            helpMenu->addAction(aboutPluginsAct);
        }

        void MainWindow::loadPlugins()
        {
            pluginsDir = QDir(qApp->applicationDirPath());
        #if defined(Q_OS_WIN)
            if (pluginsDir.dirName() == "debug" || pluginsDir.dirName() == "release")
                pluginsDir.cdUp();
        #elif defined(Q_OS_MAC)
            if (pluginsDir.dirName() == "MacOS") {
                pluginsDir.cdUp();
                pluginsDir.cdUp();
                pluginsDir.cdUp();
            }
        #endif
            pluginsDir.cd("plugins");

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

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

        void MainWindow::addToMenu(QObject *plugin, const QStringList &texts,
                                   QMenu *menu, const char *member,
                                   QActionGroup *actionGroup)
        {
            foreach (QString text, texts) {
                QAction *action = new QAction(text, plugin);
                connect(action, SIGNAL(triggered()), this, member);
                menu->addAction(action);

                if (actionGroup) {
                    action->setCheckable(true);
                    actionGroup->addAction(action);
                }
            }
        }