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 documentation 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 [email protected].
**
** 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);\n";
     } else if (field("qwidgetCtor").toBool()) {
         block += "    " + className + "(QWidget *parent);\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));
 }