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

# classwizard.cpp Example File
dialogs/classwizard/classwizard.cpp

     /****************************************************************************
     **
     ** Copyright (C) 2007-2008 Trolltech ASA. All rights reserved.
     **
     ** This file is part of the example classes of the Qt Toolkit.
     **
     ** This file may be used under the terms of the GNU General Public
     ** License versions 2.0 or 3.0 as published by the Free Software
     ** Foundation and appearing in the files LICENSE.GPL2 and LICENSE.GPL3
     ** included in the packaging of this file.  Alternatively you may (at
     ** your option) use any later version of the GNU General Public
     ** License if such license has been publicly approved by Trolltech ASA
     ** (or its successors, if any) and the KDE Free Qt Foundation. In
     ** addition, as a special exception, Trolltech gives you certain
     ** additional rights. These rights are described in the Trolltech GPL
     ** Exception version 1.2, which can be found at
     ** http://www.trolltech.com/products/qt/gplexception/ and in the file
     ** GPL_EXCEPTION.txt in this package.
     **
     ** Please review the following information to ensure GNU General
     ** Public Licensing requirements will be met:
     ** http://trolltech.com/products/qt/licenses/licensing/opensource/. If
     ** you are unsure which license is appropriate for your use, please
     ** review the following information:
     ** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
     ** or contact the sales department at sales@trolltech.com.
     **
     ** In addition, as a special exception, Trolltech, as the sole
     ** copyright holder for Qt Designer, grants users of the Qt/Eclipse
     ** Integration plug-in the right for the Qt/Eclipse Integration to
     ** link to functionality provided by Qt Designer and its related
     ** libraries.
     **
     ** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
     ** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
     ** A PARTICULAR PURPOSE. Trolltech reserves all rights not expressly
     ** granted herein.
     **
     ** 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 "classwizard.h"

     ClassWizard::ClassWizard(QWidget *parent)
         : QWizard(parent)
     {
         addPage(new IntroPage);
         addPage(new ClassInfoPage);
         addPage(new CodeStylePage);
         addPage(new OutputFilesPage);
         addPage(new ConclusionPage);

         setPixmap(QWizard::BannerPixmap, QPixmap(":/images/banner.png"));
         setPixmap(QWizard::BackgroundPixmap, QPixmap(":/images/background.png"));

         setWindowTitle(tr("Class Wizard"));
     }

     void ClassWizard::accept()
     {
         QByteArray className = field("className").toByteArray();
         QByteArray baseClass = field("baseClass").toByteArray();
         QByteArray macroName = field("macroName").toByteArray();
         QByteArray baseInclude = field("baseInclude").toByteArray();

         QString outputDir = field("outputDir").toString();
         QString header = field("header").toString();
         QString implementation = field("implementation").toString();

         QByteArray block;

         if (field("comment").toBool()) {
             block += "/*\n";
             block += "    " + header.toAscii() + "\n";
             block += "*/\n";
             block += "\n";
         }
         if (field("protect").toBool()) {
             block += "#ifndef " + macroName + "\n";
             block += "#define " + macroName + "\n";
             block += "\n";
         }
         if (field("includeBase").toBool()) {
             block += "#include " + baseInclude + "\n";
             block += "\n";
         }

         block += "class " + className;
         if (!baseClass.isEmpty())
             block += " : public " + baseClass;
         block += "\n";
         block += "{\n";

         /* qmake ignore Q_OBJECT */

         if (field("qobjectMacro").toBool()) {
             block += "    Q_OBJECT\n";
             block += "\n";
         }
         block += "public:\n";

         if (field("qobjectCtor").toBool()) {
             block += "    " + className + "(QObject *parent = 0);\n";
         } else if (field("qwidgetCtor").toBool()) {
             block += "    " + className + "(QWidget *parent = 0);\n";
         } else if (field("defaultCtor").toBool()) {
             block += "    " + className + "();\n";
             if (field("copyCtor").toBool()) {
                 block += "    " + className + "(const " + className + " &other);\n";
                 block += "\n";
                 block += "    " + className + " &operator=" + "(const " + className
                          + " &other);\n";
             }
         }
         block += "};\n";

         if (field("protect").toBool()) {
             block += "\n";
             block += "#endif\n";
         }

         QFile headerFile(outputDir + "/" + header);
         if (!headerFile.open(QFile::WriteOnly | QFile::Text)) {
             QMessageBox::warning(0, QObject::tr("Simple Wizard"),
                                  QObject::tr("Cannot write file %1:\n%2")
                                  .arg(headerFile.fileName())
                                  .arg(headerFile.errorString()));
             return;
         }
         headerFile.write(block);

         block.clear();

         if (field("comment").toBool()) {
             block += "/*\n";
             block += "    " + implementation.toAscii() + "\n";
             block += "*/\n";
             block += "\n";
         }
         block += "#include \"" + header.toAscii() + "\"\n";
         block += "\n";

         if (field("qobjectCtor").toBool()) {
             block += className + "::" + className + "(QObject *parent)\n";
             block += "    : " + baseClass + "(parent)\n";
             block += "{\n";
             block += "}\n";
         } else if (field("qwidgetCtor").toBool()) {
             block += className + "::" + className + "(QWidget *parent)\n";
             block += "    : " + baseClass + "(parent)\n";
             block += "{\n";
             block += "}\n";
         } else if (field("defaultCtor").toBool()) {
             block += className + "::" + className + "()\n";
             block += "{\n";
             block += "    // missing code\n";
             block += "}\n";

             if (field("copyCtor").toBool()) {
                 block += "\n";
                 block += className + "::" + className + "(const " + className
                          + " &other)\n";
                 block += "{\n";
                 block += "    *this = other;\n";
                 block += "}\n";
                 block += "\n";
                 block += className + " &" + className + "::operator=(const "
                          + className + " &other)\n";
                 block += "{\n";
                 if (!baseClass.isEmpty())
                     block += "    " + baseClass + "::operator=(other);\n";
                 block += "    // missing code\n";
                 block += "    return *this;\n";
                 block += "}\n";
             }
         }

         QFile implementationFile(outputDir + "/" + implementation);
         if (!implementationFile.open(QFile::WriteOnly | QFile::Text)) {
             QMessageBox::warning(0, QObject::tr("Simple Wizard"),
                                  QObject::tr("Cannot write file %1:\n%2")
                                  .arg(implementationFile.fileName())
                                  .arg(implementationFile.errorString()));
             return;
         }
         implementationFile.write(block);

         QDialog::accept();
     }

     IntroPage::IntroPage(QWidget *parent)
         : QWizardPage(parent)
     {
         setTitle(tr("Introduction"));
         setPixmap(QWizard::WatermarkPixmap, QPixmap(":/images/watermark1.png"));

         label = new QLabel(tr("This wizard will generate a skeleton C++ class "
                               "definition, including a few functions. You simply "
                               "need to specify the class name and set a few "
                               "options to produce a header file and an "
                               "implementation file for your new C++ class."));
         label->setWordWrap(true);

         QVBoxLayout *layout = new QVBoxLayout;
         layout->addWidget(label);
         setLayout(layout);
     }

     ClassInfoPage::ClassInfoPage(QWidget *parent)
         : QWizardPage(parent)
     {
         setTitle(tr("Class Information"));
         setSubTitle(tr("Specify basic information about the class for which you "
                        "want to generate skeleton source code files."));
         setPixmap(QWizard::LogoPixmap, QPixmap(":/images/logo1.png"));

         classNameLabel = new QLabel(tr("&Class name:"));
         classNameLineEdit = new QLineEdit;
         classNameLabel->setBuddy(classNameLineEdit);

         baseClassLabel = new QLabel(tr("B&ase class:"));
         baseClassLineEdit = new QLineEdit;
         baseClassLabel->setBuddy(baseClassLineEdit);

         qobjectMacroCheckBox = new QCheckBox(tr("Generate Q_OBJECT &macro"));

         groupBox = new QGroupBox(tr("C&onstructor"));

         qobjectCtorRadioButton = new QRadioButton(tr("&QObject-style constructor"));
         qwidgetCtorRadioButton = new QRadioButton(tr("Q&Widget-style constructor"));
         defaultCtorRadioButton = new QRadioButton(tr("&Default constructor"));
         copyCtorCheckBox = new QCheckBox(tr("&Generate copy constructor and "
                                             "operator="));

         defaultCtorRadioButton->setChecked(true);

         connect(defaultCtorRadioButton, SIGNAL(toggled(bool)),
                 copyCtorCheckBox, SLOT(setEnabled(bool)));

         registerField("className*", classNameLineEdit);
         registerField("baseClass", baseClassLineEdit);
         registerField("qobjectMacro", qobjectMacroCheckBox);
         registerField("qobjectCtor", qobjectCtorRadioButton);
         registerField("qwidgetCtor", qwidgetCtorRadioButton);
         registerField("defaultCtor", defaultCtorRadioButton);
         registerField("copyCtor", copyCtorCheckBox);

         QVBoxLayout *groupBoxLayout = new QVBoxLayout;
         groupBoxLayout->addWidget(qobjectCtorRadioButton);
         groupBoxLayout->addWidget(qwidgetCtorRadioButton);
         groupBoxLayout->addWidget(defaultCtorRadioButton);
         groupBoxLayout->addWidget(copyCtorCheckBox);
         groupBox->setLayout(groupBoxLayout);

         QGridLayout *layout = new QGridLayout;
         layout->addWidget(classNameLabel, 0, 0);
         layout->addWidget(classNameLineEdit, 0, 1);
         layout->addWidget(baseClassLabel, 1, 0);
         layout->addWidget(baseClassLineEdit, 1, 1);
         layout->addWidget(qobjectMacroCheckBox, 2, 0, 1, 2);
         layout->addWidget(groupBox, 3, 0, 1, 2);
         setLayout(layout);
     }

     CodeStylePage::CodeStylePage(QWidget *parent)
         : QWizardPage(parent)
     {
         setTitle(tr("Code Style Options"));
         setSubTitle(tr("Choose the formatting of the generated code."));
         setPixmap(QWizard::LogoPixmap, QPixmap(":/images/logo2.png"));

         commentCheckBox = new QCheckBox(tr("&Start generated files with a "
                                            "comment"));
         commentCheckBox->setChecked(true);

         protectCheckBox = new QCheckBox(tr("&Protect header file against multiple "
                                            "inclusions"));
         protectCheckBox->setChecked(true);

         macroNameLabel = new QLabel(tr("&Macro name:"));
         macroNameLineEdit = new QLineEdit;
         macroNameLabel->setBuddy(macroNameLineEdit);

         includeBaseCheckBox = new QCheckBox(tr("&Include base class definition"));
         baseIncludeLabel = new QLabel(tr("Base class include:"));
         baseIncludeLineEdit = new QLineEdit;
         baseIncludeLabel->setBuddy(baseIncludeLineEdit);

         connect(protectCheckBox, SIGNAL(toggled(bool)),
                 macroNameLabel, SLOT(setEnabled(bool)));
         connect(protectCheckBox, SIGNAL(toggled(bool)),
                 macroNameLineEdit, SLOT(setEnabled(bool)));
         connect(includeBaseCheckBox, SIGNAL(toggled(bool)),
                 baseIncludeLabel, SLOT(setEnabled(bool)));
         connect(includeBaseCheckBox, SIGNAL(toggled(bool)),
                 baseIncludeLineEdit, SLOT(setEnabled(bool)));

         registerField("comment", commentCheckBox);
         registerField("protect", protectCheckBox);
         registerField("macroName", macroNameLineEdit);
         registerField("includeBase", includeBaseCheckBox);
         registerField("baseInclude", baseIncludeLineEdit);

         QGridLayout *layout = new QGridLayout;
         layout->setColumnMinimumWidth(0, 20);
         layout->addWidget(commentCheckBox, 0, 0, 1, 3);
         layout->addWidget(protectCheckBox, 1, 0, 1, 3);
         layout->addWidget(macroNameLabel, 2, 1);
         layout->addWidget(macroNameLineEdit, 2, 2);
         layout->addWidget(includeBaseCheckBox, 3, 0, 1, 3);
         layout->addWidget(baseIncludeLabel, 4, 1);
         layout->addWidget(baseIncludeLineEdit, 4, 2);
         setLayout(layout);
     }

     void CodeStylePage::initializePage()
     {
         QString className = field("className").toString();
         macroNameLineEdit->setText(className.toUpper() + "_H");

         QString baseClass = field("baseClass").toString();

         includeBaseCheckBox->setChecked(!baseClass.isEmpty());
         includeBaseCheckBox->setEnabled(!baseClass.isEmpty());
         baseIncludeLabel->setEnabled(!baseClass.isEmpty());
         baseIncludeLineEdit->setEnabled(!baseClass.isEmpty());

         if (baseClass.isEmpty()) {
             baseIncludeLineEdit->clear();
         } else if (QRegExp("Q[A-Z].*").exactMatch(baseClass)) {
             baseIncludeLineEdit->setText("<" + baseClass + ">");
         } else {
             baseIncludeLineEdit->setText("\"" + baseClass.toLower() + ".h\"");
         }
     }

     OutputFilesPage::OutputFilesPage(QWidget *parent)
         : QWizardPage(parent)
     {
         setTitle(tr("Output Files"));
         setSubTitle(tr("Specify where you want the wizard to put the generated "
                        "skeleton code."));
         setPixmap(QWizard::LogoPixmap, QPixmap(":/images/logo3.png"));

         outputDirLabel = new QLabel(tr("&Output directory:"));
         outputDirLineEdit = new QLineEdit;
         outputDirLabel->setBuddy(outputDirLineEdit);

         headerLabel = new QLabel(tr("&Header file name:"));
         headerLineEdit = new QLineEdit;
         headerLabel->setBuddy(headerLineEdit);

         implementationLabel = new QLabel(tr("&Implementation file name:"));
         implementationLineEdit = new QLineEdit;
         implementationLabel->setBuddy(implementationLineEdit);

         registerField("outputDir*", outputDirLineEdit);
         registerField("header*", headerLineEdit);
         registerField("implementation*", implementationLineEdit);

         QGridLayout *layout = new QGridLayout;
         layout->addWidget(outputDirLabel, 0, 0);
         layout->addWidget(outputDirLineEdit, 0, 1);
         layout->addWidget(headerLabel, 1, 0);
         layout->addWidget(headerLineEdit, 1, 1);
         layout->addWidget(implementationLabel, 2, 0);
         layout->addWidget(implementationLineEdit, 2, 1);
         setLayout(layout);
     }

     void OutputFilesPage::initializePage()
     {
         QString className = field("className").toString();
         headerLineEdit->setText(className.toLower() + ".h");
         implementationLineEdit->setText(className.toLower() + ".cpp");
         outputDirLineEdit->setText(QDir::convertSeparators(QDir::tempPath()));
     }

     ConclusionPage::ConclusionPage(QWidget *parent)
         : QWizardPage(parent)
     {
         setTitle(tr("Conclusion"));
         setPixmap(QWizard::WatermarkPixmap, QPixmap(":/images/watermark2.png"));

         label = new QLabel;
         label->setWordWrap(true);

         QVBoxLayout *layout = new QVBoxLayout;
         layout->addWidget(label);
         setLayout(layout);
     }

     void ConclusionPage::initializePage()
     {
         QString finishText = wizard()->buttonText(QWizard::FinishButton);
         finishText.remove('&');
         label->setText(tr("Click %1 to generate the class skeleton.")
                        .arg(finishText));
     }