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

# mainwindow.cpp Example File
mainwindows/sdi/mainwindow.cpp

        /****************************************************************************
        **
        ** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
        **
        ** This file is part of the documentation of the Qt Toolkit.
        **
        ** This file may be used under the terms of the GNU General Public
        ** License version 2.0 as published by the Free Software Foundation
        ** and appearing in the file LICENSE.GPL included in the packaging of
        ** this file.  Please review the following information to ensure GNU
        ** General Public Licensing requirements will be met:
        ** http://www.trolltech.com/products/qt/opensource.html
        **
        ** If you are unsure which license is appropriate for your use, please
        ** review the following information:
        ** http://www.trolltech.com/products/qt/licensing.html or contact the
        ** sales department at sales@trolltech.com.
        **
        ** 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 "mainwindow.h"

        MainWindow::MainWindow()
        {
            init();
            setCurrentFile("");
        }

        MainWindow::MainWindow(const QString &fileName)
        {
            init();
            loadFile(fileName);
        }

        void MainWindow::closeEvent(QCloseEvent *event)
        {
            if (maybeSave()) {
                writeSettings();
                event->accept();
            } else {
                event->ignore();
            }
        }

        void MainWindow::newFile()
        {
            MainWindow *other = new MainWindow;
            other->move(x() + 40, y() + 40);
            other->show();
        }

        void MainWindow::open()
        {
            QString fileName = QFileDialog::getOpenFileName(this);
            if (!fileName.isEmpty()) {
                MainWindow *existing = findMainWindow(fileName);
                if (existing) {
                    existing->show();
                    existing->raise();
                    existing->activateWindow();
                    return;
                }

                if (isUntitled && textEdit->document()->isEmpty()
                        && !isWindowModified()) {
                    loadFile(fileName);
                } else {
                    MainWindow *other = new MainWindow(fileName);
                    if (other->isUntitled) {
                        delete other;
                        return;
                    }
                    other->move(x() + 40, y() + 40);
                    other->show();
                }
            }
        }

        bool MainWindow::save()
        {
            if (isUntitled) {
                return saveAs();
            } else {
                return saveFile(curFile);
            }
        }

        bool MainWindow::saveAs()
        {
            QString fileName = QFileDialog::getSaveFileName(this, tr("Save As"),
                                                            curFile);
            if (fileName.isEmpty())
                return false;

            return saveFile(fileName);
        }

        void MainWindow::about()
        {
           QMessageBox::about(this, tr("About SDI"),
                    tr("The <b>SDI</b> example demonstrates how to write single "
                       "document interface applications using Qt."));
        }

        void MainWindow::documentWasModified()
        {
            setWindowModified(true);
        }

        void MainWindow::init()
        {
            setAttribute(Qt::WA_DeleteOnClose);

            isUntitled = true;

            textEdit = new QTextEdit;
            setCentralWidget(textEdit);

            createActions();
            createMenus();
            createToolBars();
            createStatusBar();

            readSettings();

            connect(textEdit->document(), SIGNAL(contentsChanged()),
                    this, SLOT(documentWasModified()));
        }

        void MainWindow::createActions()
        {
            newAct = new QAction(QIcon(":/images/new.png"), tr("&New"), this);
            newAct->setShortcut(tr("Ctrl+N"));
            newAct->setStatusTip(tr("Create a new file"));
            connect(newAct, SIGNAL(triggered()), this, SLOT(newFile()));

            openAct = new QAction(QIcon(":/images/open.png"), tr("&Open..."), this);
            openAct->setShortcut(tr("Ctrl+O"));
            openAct->setStatusTip(tr("Open an existing file"));
            connect(openAct, SIGNAL(triggered()), this, SLOT(open()));

            saveAct = new QAction(QIcon(":/images/save.png"), tr("&Save"), this);
            saveAct->setShortcut(tr("Ctrl+S"));
            saveAct->setStatusTip(tr("Save the document to disk"));
            connect(saveAct, SIGNAL(triggered()), this, SLOT(save()));

            saveAsAct = new QAction(tr("Save &As..."), this);
            saveAsAct->setStatusTip(tr("Save the document under a new name"));
            connect(saveAsAct, SIGNAL(triggered()), this, SLOT(saveAs()));

            closeAct = new QAction(tr("&Close"), this);
            closeAct->setShortcut(tr("Ctrl+W"));
            closeAct->setStatusTip(tr("Close this window"));
            connect(closeAct, SIGNAL(triggered()), this, SLOT(close()));

            exitAct = new QAction(tr("E&xit"), this);
            exitAct->setShortcut(tr("Ctrl+Q"));
            exitAct->setStatusTip(tr("Exit the application"));
            connect(exitAct, SIGNAL(triggered()), qApp, SLOT(closeAllWindows()));

            cutAct = new QAction(QIcon(":/images/cut.png"), tr("Cu&t"), this);
            cutAct->setShortcut(tr("Ctrl+X"));
            cutAct->setStatusTip(tr("Cut the current selection's contents to the "
                                    "clipboard"));
            connect(cutAct, SIGNAL(triggered()), textEdit, SLOT(cut()));

            copyAct = new QAction(QIcon(":/images/copy.png"), tr("&Copy"), this);
            copyAct->setShortcut(tr("Ctrl+C"));
            copyAct->setStatusTip(tr("Copy the current selection's contents to the "
                                     "clipboard"));
            connect(copyAct, SIGNAL(triggered()), textEdit, SLOT(copy()));

            pasteAct = new QAction(QIcon(":/images/paste.png"), tr("&Paste"), this);
            pasteAct->setShortcut(tr("Ctrl+V"));
            pasteAct->setStatusTip(tr("Paste the clipboard's contents into the current "
                                      "selection"));
            connect(pasteAct, SIGNAL(triggered()), textEdit, SLOT(paste()));

            aboutAct = new QAction(tr("&About"), this);
            aboutAct->setStatusTip(tr("Show the application's About box"));
            connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));

            aboutQtAct = new QAction(tr("About &Qt"), this);
            aboutQtAct->setStatusTip(tr("Show the Qt library's About box"));
            connect(aboutQtAct, SIGNAL(triggered()), qApp, SLOT(aboutQt()));

            cutAct->setEnabled(false);
            copyAct->setEnabled(false);
            connect(textEdit, SIGNAL(copyAvailable(bool)),
                    cutAct, SLOT(setEnabled(bool)));
            connect(textEdit, SIGNAL(copyAvailable(bool)),
                    copyAct, SLOT(setEnabled(bool)));
        }

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

            editMenu = menuBar()->addMenu(tr("&Edit"));
            editMenu->addAction(cutAct);
            editMenu->addAction(copyAct);
            editMenu->addAction(pasteAct);

            menuBar()->addSeparator();

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

        void MainWindow::createToolBars()
        {
            fileToolBar = addToolBar(tr("File"));
            fileToolBar->addAction(newAct);
            fileToolBar->addAction(openAct);
            fileToolBar->addAction(saveAct);

            editToolBar = addToolBar(tr("Edit"));
            editToolBar->addAction(cutAct);
            editToolBar->addAction(copyAct);
            editToolBar->addAction(pasteAct);
        }

        void MainWindow::createStatusBar()
        {
            statusBar()->showMessage(tr("Ready"));
        }

        void MainWindow::readSettings()
        {
            QSettings settings("Trolltech", "SDI Example");
            QPoint pos = settings.value("pos", QPoint(200, 200)).toPoint();
            QSize size = settings.value("size", QSize(400, 400)).toSize();
            move(pos);
            resize(size);
        }

        void MainWindow::writeSettings()
        {
            QSettings settings("Trolltech", "SDI Example");
            settings.setValue("pos", pos());
            settings.setValue("size", size());
        }

        bool MainWindow::maybeSave()
        {
            if (textEdit->document()->isModified()) {
                int ret = QMessageBox::warning(this, tr("SDI"),
                             tr("The document has been modified.\n"
                                "Do you want to save your changes?"),
                             QMessageBox::Yes | QMessageBox::Default,
                             QMessageBox::No,
                             QMessageBox::Cancel | QMessageBox::Escape);
                if (ret == QMessageBox::Yes)
                    return save();
                else if (ret == QMessageBox::Cancel)
                    return false;
            }
            return true;
        }

        void MainWindow::loadFile(const QString &fileName)
        {

            QFile file(fileName);
            if (!file.open(QFile::ReadOnly | QFile::Text)) {
                QMessageBox::warning(this, tr("SDI"),
                                     tr("Cannot read file %1:\n%2.")
                                     .arg(fileName)
                                     .arg(file.errorString()));
                return;
            }

            QTextStream in(&file);
            QApplication::setOverrideCursor(Qt::WaitCursor);
            textEdit->setPlainText(in.readAll());
            QApplication::restoreOverrideCursor();

            setCurrentFile(fileName);
            statusBar()->showMessage(tr("File loaded"), 2000);
        }

        bool MainWindow::saveFile(const QString &fileName)
        {
            QFile file(fileName);
            if (!file.open(QFile::WriteOnly | QFile::Text)) {
                QMessageBox::warning(this, tr("SDI"),
                                     tr("Cannot write file %1:\n%2.")
                                     .arg(fileName)
                                     .arg(file.errorString()));
                return false;
            }

            QTextStream out(&file);
            QApplication::setOverrideCursor(Qt::WaitCursor);
            out << textEdit->toPlainText();
            QApplication::restoreOverrideCursor();

            setCurrentFile(fileName);
            statusBar()->showMessage(tr("File saved"), 2000);
            return true;
        }

        void MainWindow::setCurrentFile(const QString &fileName)
        {
            static int sequenceNumber = 1;

            isUntitled = fileName.isEmpty();
            if (isUntitled) {
                curFile = tr("document%1.txt").arg(sequenceNumber++);
            } else {
                curFile = QFileInfo(fileName).canonicalFilePath();
            }

            textEdit->document()->setModified(false);
            setWindowModified(false);

            setWindowTitle(tr("%1[*] - %2").arg(strippedName(curFile))
                                               .arg(tr("SDI")));
        }

        QString MainWindow::strippedName(const QString &fullFileName)
        {
            return QFileInfo(fullFileName).fileName();
        }

        MainWindow *MainWindow::findMainWindow(const QString &fileName)
        {
            QString canonicalFilePath = QFileInfo(fileName).canonicalFilePath();

            foreach (QWidget *widget, qApp->topLevelWidgets()) {
                MainWindow *mainWin = qobject_cast<MainWindow *>(widget);
                if (mainWin && mainWin->curFile == canonicalFilePath)
                    return mainWin;
            }
            return 0;
        }