KDevelop API Documentation

cppnewclassdlg.cpp

Go to the documentation of this file.
00001 /***************************************************************************
00002 *   Copyright (C) 1998 by Sandy Meier                                     *
00003 *   smeier@rz.uni-potsdam.de                                              *
00004 *   Copyright (C) 1999 by Benoit.Cerrina                                  *
00005 *   Benoit.Cerrina@writeme.com                                            *
00006 *   Copyright (C) 2002 by Bernd Gehrmann                                  *
00007 *   bernd@kdevelop.org                                                    *
00008 *   Copyright (C) 2003 by Eray Ozkural                                    *
00009 *   <erayo@cs.bilkent.edu.tr>                                             *
00010 *   Copyright (C) 2003 by Alexander Dymo                                  *
00011 *   cloudtemple@mksat.net                                                 *
00012 *                                                                         *
00013 *   This program is free software; you can redistribute it and/or modify  *
00014 *   it under the terms of the GNU General Public License as published by  *
00015 *   the Free Software Foundation; either version 2 of the License, or     *
00016 *   (at your option) any later version.                                   *
00017 *                                                                         *
00018 ***************************************************************************/
00019 
00020 #include "cppnewclassdlg.h"
00021 
00022 #include <qcheckbox.h>
00023 #include <qfile.h>
00024 #include <qfileinfo.h>
00025 #include <qradiobutton.h>
00026 #include <qregexp.h>
00027 #include <qtextedit.h>
00028 #include <qrect.h>
00029 #include <qstyle.h>
00030 
00031 #include <kdebug.h>
00032 #include <klocale.h>
00033 #include <kmessagebox.h>
00034 #include <qcombobox.h>
00035 #include <qlistview.h>
00036 #include <qpopupmenu.h>
00037 #include <qpushbutton.h>
00038 #include <qtabwidget.h>
00039 #include <klineedit.h>
00040 #include <kdeversion.h>
00041 
00042 #include "kdevlanguagesupport.h"
00043 #include "kdevproject.h"
00044 #include "kdevsourceformatter.h"
00045 #include "domutil.h"
00046 #include "filetemplate.h"
00047 
00048 #include "classgeneratorconfig.h"
00049 
00050 QString QRegExp_escape(const QString& str )
00051 {
00052 #if QT_VERSION >= 0x030100
00053     return QRegExp::escape(str);
00054 #else
00055     // this block is copyrighted by Trolltech AS (GPL)
00056     static const char meta[] = "$()*+.?[\\]^{|}";
00057     QString quoted = str;
00058     int i = 0;
00059 
00060     while ( i < (int) quoted.length() ) {
00061        if ( strchr(meta, quoted[i].latin1()) != 0 )
00062            quoted.insert( i++, "\\" );
00063        i++;
00064     }
00065     return quoted;
00066 #endif
00067 }
00068 
00069 CppNewClassDialog::CppNewClassDialog(KDevLanguageSupport *part, QWidget *parent, const char *name)
00070     : CppNewClassDialogBase(parent, name)
00071 {
00072     headerModified = false;
00073     baseincludeModified = false;
00074     implementationModified = false;
00075     m_part = part;
00076     // read file template configuration
00077     //    KDevProject *project = part->project();
00078     QDomDocument &dom = *part->projectDom();
00079     interface_url = DomUtil::readEntry(dom, "/cppsupportpart/filetemplates/interfaceURL");
00080     implementation_url = DomUtil::readEntry(dom, "/cppsupportpart/filetemplates/implementationURL");
00081     interface_suffix = DomUtil::readEntry(dom, "/cppsupportpart/filetemplates/interfacesuffix", ".h");
00082     implementation_suffix = DomUtil::readEntry(dom, "/cppsupportpart/filetemplates/implementationsuffix", ".cpp");
00083     lowercase_filenames = DomUtil::readBoolEntry(dom, "/cppsupportpart/filetemplates/lowercasefilenames", true);
00084     m_parse = DomUtil::readEntry( *m_part->projectDom(), "/cppsupportpart/newclass/filenamesetting","none");
00085     //    name_handler_combo->setCurrentText(m_parse);
00086     baseclasses_view->setSorting(-1);
00087     constructors_view->setSorting(-1);
00088 
00089     accessMenu = new QPopupMenu(this);
00090     accessMenu->insertItem(i18n("Use as Private"),
00091         this, SLOT(changeToPrivate()), 0, 1);
00092     accessMenu->insertItem(i18n("Use as Protected"),
00093         this, SLOT(changeToProtected()), 0, 2);
00094     accessMenu->insertItem(i18n("Use as Public"),
00095         this, SLOT(changeToPublic()), 0, 3);
00096     accessMenu->insertSeparator();
00097     accessMenu->insertItem(i18n("Unset"),
00098         this, SLOT(changeToInherited()), 0, 5);
00099 
00100     overMenu = new QPopupMenu(this);
00101     overMenu->insertItem(i18n("Extend Base Class Functionality"),
00102         this, SLOT(extendFunctionality()), 0, 11);
00103     overMenu->insertItem(i18n("Replace Base Class Method"),
00104         this, SLOT(replaceFunctionality()), 0, 12);
00105 
00106     compBasename = basename_edit->completionObject();
00107     setCompletionBasename(m_part->codeModel());
00108     compNamespace = namespace_edit->completionObject();
00109     setCompletionNamespaceRecursive(m_part->codeModel()->globalNamespace());
00110     classname_edit->setFocus();
00111 }
00112 
00113 
00114 CppNewClassDialog::~CppNewClassDialog()
00115 {
00116     delete compBasename;
00117     delete compNamespace;
00118 }
00119 
00120 void CppNewClassDialog::setCompletionBasename(CodeModel *model)
00121 {
00122     compBasename->clear();
00123   
00124     // Import selected namespace without qualifier
00125     NamespaceDom namespaceDom = model->globalNamespace();
00126     
00127     QStringList::const_iterator it = currNamespace.begin();
00128     for ( ; it != currNamespace.end() ; ++it ) {
00129     if( ! namespaceDom->hasNamespace(*it) )
00130         break;
00131     namespaceDom = namespaceDom->namespaceByName(*it);
00132     }
00133     
00134     if(it == currNamespace.end())
00135     // complete namespace has been found (not breaked)
00136     compBasename->insertItems(sortedNameList( namespaceDom -> classList() ));
00137     
00138     addCompletionBasenameNamespacesRecursive(model->globalNamespace());
00139     
00140     QStringList compItems = compBasename->items();
00141     it = compItems.begin();
00142     for(int i=0;
00143     it != compItems.end(); ++it, ++i) 
00144     kdDebug(9007) << "compBasename->items()[" << i << "] = \"" << *it << "\"" << endl;
00145  }
00146 
00147 QStringList& gres( QStringList &list, const QRegExp & rx, const QString & after )
00148 {
00149     QStringList::Iterator it = list.begin();
00150     while ( it != list.end() ) {
00151         (*it).replace( rx, after);
00152         ++it;
00153     }
00154     return list;
00155 }
00156 
00157 void CppNewClassDialog::addCompletionBasenameNamespacesRecursive(const NamespaceDom & namespaceDom,
00158                                  const QString & namespaceParent)
00159 {
00160     // Add classes of this namespace
00161     QStringList classList = sortedNameList( namespaceDom -> classList() );
00162 
00163     if(! namespaceParent.isEmpty() ) {
00164 #if QT_VERSION >= 0x030200
00165     classList.gres( QRegExp("^"), namespaceParent + "::" );
00166 #else
00167     gres(classList, QRegExp("^"), namespaceParent + "::" );
00168 #endif
00169     }
00170 
00171     compBasename -> insertItems(classList);
00172 
00173     
00174     // Recursion
00175     NamespaceList namespaceList = namespaceDom->namespaceList();
00176     NamespaceList::const_iterator it = namespaceList.begin();
00177     
00178     for( ; it != namespaceList.end() ; ++it ) {
00179     QString fullNamespace;
00180     
00181     if(! namespaceParent.isEmpty() ) 
00182         fullNamespace = namespaceParent+"::";
00183     
00184     fullNamespace += (*it) -> name();
00185     addCompletionBasenameNamespacesRecursive( *it, fullNamespace );
00186     }
00187 }
00188 
00189 
00190 void CppNewClassDialog::setCompletionNamespaceRecursive( const NamespaceDom & namespaceDom, const QString & namespaceParent )
00191 {
00192     NamespaceList namespaceList = namespaceDom->namespaceList();
00193     NamespaceList::const_iterator it = namespaceList.begin();
00194     for( ; it != namespaceList.end() ; ++it ) {
00195     QString fullNamespace;
00196     
00197     if(! namespaceParent.isEmpty() )
00198         fullNamespace = namespaceParent+"::";
00199     
00200     fullNamespace += (*it) -> name();
00201     kdDebug(9007) << "compNamespace -> addItem( \"" << fullNamespace << "\" )" << endl;
00202     compNamespace -> addItem( fullNamespace );
00203     setCompletionNamespaceRecursive( *it, fullNamespace );
00204     }
00205 }
00206 
00207 void CppNewClassDialog::nameHandlerChanged(const QString &text)
00208 {
00209     DomUtil::writeEntry( *m_part->projectDom(), "/cppsupportpart/newclass/filenamesetting",text);
00210     m_parse = text;
00211     classNameChanged(classname_edit->text());
00212 }
00213 
00214 void CppNewClassDialog::classNameChanged(const QString &text)
00215 {
00216     QString str = text;
00217 
00218     if (!headerModified) {
00219         QString header = str + interface_suffix;
00220         switch( gen_config->fileCase() )
00221         {
00222             case ClassGeneratorConfig::LowerCase:
00223                 header = header.lower();
00224                 break;
00225             case ClassGeneratorConfig::UpperCase:
00226                 header = header.upper();
00227                 break;
00228             default:;
00229         }
00230         header = header.replace(QRegExp("(template *<.*> *)?(class *)?"), "");
00231         header_edit->setText(header);
00232     }
00233     if (!implementationModified) {
00234         QString implementation;
00235         if (str.contains("template"))
00236             implementation = str + "_impl" + interface_suffix;
00237         else
00238             implementation = str + implementation_suffix;
00239         switch( gen_config->fileCase() )
00240         {
00241             case ClassGeneratorConfig::LowerCase:
00242                 implementation = implementation.lower();
00243                 break;
00244             case ClassGeneratorConfig::UpperCase:
00245                 implementation = implementation.upper();
00246                 break;
00247             default:;
00248         }
00249         implementation = implementation.replace(QRegExp("(template *<.*> *)?(class *)?"), "");
00250         implementation_edit->setText(implementation);
00251     }
00252 }
00253 
00254 void CppNewClassDialog::classNamespaceChanged(const QString &text)
00255 {  
00256     currNamespace = QStringList::split(QString("::"), text);
00257     setCompletionBasename(m_part -> codeModel());
00258     reloadAdvancedInheritance(true);
00259 }
00260 
00261 void CppNewClassDialog::baseclassname_changed(const QString &text)
00262 {
00263     if ( (basename_edit->hasFocus()) && (!baseincludeModified) ) {
00264         QString header = text;
00265     if (header.contains(QRegExp("::")))
00266       header = header.mid(header.findRev(QRegExp("::"))+2);
00267         header = header.replace(QRegExp(" *<.*>"), "");
00268     header += interface_suffix;
00269     
00270     switch( gen_config->superCase() )
00271         {
00272             case ClassGeneratorConfig::LowerCase:
00273                 header = header.lower();
00274                 break;
00275             case ClassGeneratorConfig::UpperCase:
00276                 header = header.upper();
00277                 break;
00278             default:;
00279         }
00280     
00281         baseinclude_edit->setText(header);
00282     }
00283 }
00284 
00285 void CppNewClassDialog::baseIncludeChanged(const QString &text)
00286 {
00287     if (baseinclude_edit->hasFocus())
00288     {
00289         baseincludeModified = true;
00290         if ( baseclasses_view->selectedItem() )
00291             baseclasses_view->selectedItem()->setText(4, "true");
00292     }
00293     if ( baseclasses_view->selectedItem() )
00294     {
00295         baseclasses_view->selectedItem()->setText(3, text);
00296     }
00297 }
00298 
00299 void CppNewClassDialog::headerChanged()
00300 {
00301     // Only if a change caused by the user himself
00302     if (header_edit->hasFocus())
00303         headerModified = true;
00304 }
00305 
00306 
00307 void CppNewClassDialog::implementationChanged()
00308 {
00309     // Only if a change caused by the user himself
00310     if (implementation_edit->hasFocus())
00311         implementationModified = true;
00312 }
00313 
00314 void CppNewClassDialog::checkObjCInheritance(int val)
00315 {
00316     childclass_box->setEnabled(!val);
00317     gtk_box->setEnabled(!val);
00318     qobject_box->setEnabled(!val);
00319     namespace_edit->setEnabled(!val);
00320     class_tabs->setTabEnabled(tab2, !val);
00321 /*    virtual_box->setEnabled(!val);
00322     public_button->setEnabled(!val);
00323     protected_button->setEnabled(!val);
00324     private_button->setEnabled(!val);*/
00325     if (val && (baseclasses_view->childCount() > 1))
00326         if (KMessageBox::warningContinueCancel(this,
00327         i18n("Objective C does not support multiple inheritance.\nOnly the first base class in the list will be taken into account."),
00328         i18n("Warning"), KStdGuiItem::cont(), "Check Objective C inheritance rules" ) == KMessageBox::Cancel)
00329         objc_box->setChecked(false);
00330 }
00331 
00332 void CppNewClassDialog::checkQWidgetInheritance(int val)
00333 {
00334     if (val)
00335     {
00336         qobject_box->setEnabled(val);
00337     qobject_box->setChecked(val);
00338         objc_box->setEnabled(!val);
00339     gtk_box->setEnabled(!val);
00340     }
00341     else if (qobject_box->isChecked())
00342     {
00343         objc_box->setEnabled(false);
00344     gtk_box->setEnabled(false);
00345     }
00346     else
00347     {
00348         objc_box->setEnabled(!val);
00349     gtk_box->setEnabled(!val);
00350     }
00351 
00352 
00353     if (val)
00354     {
00355         if (baseclasses_view->childCount() == 0)
00356         {
00357             addBaseClass();
00358             basename_edit->setText("QWidget");
00359         }
00360 /*        constructors_cpp_edit->append(classname_edit->text() + "::" + classname_edit->text() +
00361             "(QWidget *parent, const char *name):\n    QWidget(parent, name)\n{\n}\n");
00362         constructors_h_edit->append(classname_edit->text() + "(QWidget *parent, const char *name);\n");*/
00363     }
00364 
00365     if (val && (baseclasses_view->childCount() > 1))
00366         if (KMessageBox::warningContinueCancel(this,
00367             i18n("Multiple inheritance requires QObject derivative to be first and unique in base class list."),
00368             i18n("Warning"), KStdGuiItem::cont(), "Check QWidget inheritance rules" ) == KMessageBox::Cancel)
00369             childclass_box->setChecked(false);
00370 }
00371 
00372 void CppNewClassDialog::qobject_box_stateChanged(int val)
00373 {
00374     if ( childclass_box->isChecked() )
00375         return;
00376 
00377     if (baseclasses_view->childCount() == 0)
00378     {
00379         addBaseClass();
00380         basename_edit->setText("QObject");
00381     }
00382 
00383     
00384     objc_box->setEnabled(!val);
00385     gtk_box->setEnabled(!val);
00386 }
00387 
00388 void CppNewClassDialog::gtk_box_stateChanged(int val)
00389 {
00390     class_tabs->setTabEnabled(tab2, !val);
00391     childclass_box->setEnabled(!val);
00392     objc_box->setEnabled(!val);
00393     qobject_box->setEnabled(!val);
00394     namespace_edit->setEnabled(!val);
00395 
00396     basename_edit->setEnabled(!val);
00397     virtual_box->setEnabled(!val);
00398     public_button->setEnabled(!val);
00399     protected_button->setEnabled(!val);
00400     private_button->setEnabled(!val);
00401     addbaseclass_button->setEnabled(!val);
00402     rembaseclass_button->setEnabled(!val);
00403     upbaseclass_button->setEnabled(!val);
00404     downbaseclass_button->setEnabled(!val);
00405     baseclasses_view->setEnabled(!val);
00406     baseinclude_edit->setEnabled(!val);
00407 }
00408 
00409 
00410 void CppNewClassDialog::accept()
00411 {
00412   ClassGenerator generator(*this);
00413   if (generator.generate())
00414     QDialog::accept();
00415 
00416 }
00417 
00418 void CppNewClassDialog::setStateOfInheritanceEditors(bool state, bool hideList)
00419 {
00420     basename_edit->setEnabled(state);
00421     virtual_box->setEnabled(state);
00422     public_button->setEnabled(state);
00423     protected_button->setEnabled(state);
00424     private_button->setEnabled(state);
00425     scope_box->setEnabled(state);
00426     baseinclude_edit->setEnabled(state);
00427     if (state)
00428         baseclasses_view->setEnabled(state);
00429     else
00430         baseclasses_view->setEnabled(hideList ? state : true);
00431     rembaseclass_button->setEnabled(state);
00432     if (!state)
00433     {
00434         upbaseclass_button->setEnabled(state);
00435         downbaseclass_button->setEnabled(state);
00436     }
00437 }
00438 
00439 void CppNewClassDialog::addBaseClass()
00440 {
00441     baseincludeModified = false;
00442     if (baseclasses_view->selectedItem())
00443         baseclasses_view->selectedItem()->setSelected(false);
00444     QListViewItem* it = new QListViewItem(baseclasses_view, baseclasses_view->lastItem(),
00445         QString::null, "public", QString("%1").arg(scope_box->currentItem()), QString::null, "false");
00446     setStateOfInheritanceEditors(true);
00447     public_button->setChecked(true);
00448     virtual_box->setChecked(false);
00449     basename_edit->setText(QString::null);
00450     basename_edit->setFocus();
00451     baseclasses_view->setSelected(it, true);
00452 }
00453 
00454 void CppNewClassDialog::remBaseClass()
00455 {
00456     bool basename_focused = false;
00457     if (basename_edit->hasFocus())
00458     {
00459         basename_focused = true;
00460         basename_edit->clearFocus();
00461     }
00462     if (baseclasses_view->selectedItem())
00463     {
00464         QListViewItem *it = baseclasses_view->selectedItem();
00465         remClassFromAdv(it->text(0));
00466         baseclasses_view->selectedItem()->setSelected(false);
00467         if (it->itemBelow())
00468             baseclasses_view->setSelected(it->itemBelow(), true);
00469         else if (it->itemAbove())
00470             baseclasses_view->setSelected(it->itemAbove(), true);
00471         delete it;
00472         if (baseclasses_view->childCount() == 0)
00473             setStateOfInheritanceEditors(false);
00474         baseincludeModified = false;
00475     }
00476     if (basename_focused)
00477         basename_edit->setFocus();
00478 }
00479 
00480 void CppNewClassDialog::remBaseClassOnly()
00481 {
00482     if (baseclasses_view->selectedItem())
00483     {
00484         QListViewItem *it = baseclasses_view->selectedItem();
00485         baseclasses_view->selectedItem()->setSelected(false);
00486         if (it->itemBelow())
00487             baseclasses_view->setSelected(it->itemBelow(), true);
00488         else if (it->itemAbove())
00489             baseclasses_view->setSelected(it->itemAbove(), true);
00490         delete it;
00491         if (baseclasses_view->childCount() == 0)
00492             setStateOfInheritanceEditors(false);
00493         baseincludeModified = true;
00494     }
00495 }
00496 
00497 void CppNewClassDialog::remClassFromAdv(QString text)
00498 {
00499     // Strip off namespace qualification
00500     if(text.contains("::"))
00501         text = text.mid(text.findRev("::")+2);
00502      
00503     removeTemplateParams(text);
00504     QListViewItem *it = 0;
00505     if ((it = access_view->findItem(text, 0)))
00506         delete it;
00507     if ((it = methods_view->findItem(text, 0)))
00508         delete it;
00509     if ((it = constructors_view->findItem(text, 0)))
00510     {
00512         // and constructors_h_edit must be implemented
00513 
00514 /*        int *para = new int(1);
00515         int *index = new int(1);
00516         if (constructors_cpp_edit->find(text + "(", true, false, true, para, index))
00517         {
00518             qWarning("%s( found", text.latin1());
00519             if (para) constructors_cpp_edit->removeParagraph(*para);
00520         }*/
00521         delete it;
00522     }
00523 }
00524 
00525 void CppNewClassDialog::currBaseNameChanged(const QString &text)
00526 {
00527     if ( baseclasses_view->selectedItem() && (basename_edit->hasFocus()))
00528     {
00529         if (class_tabs->isTabEnabled(tab2))
00530         {
00531             //check for this class in the adv. inheritance lists
00532             //and delete if it exists
00533             remClassFromAdv(baseclasses_view->selectedItem()->text(0));
00534             //parse new base class
00535             parseClass(text, baseclasses_view->selectedItem()->text(1));
00536         }
00537         baseclasses_view->selectedItem()->setText(0, text);
00538         updateConstructorsOrder();
00539     }
00540 }
00541 
00542 void CppNewClassDialog::currBasePrivateSet()
00543 {
00544     if ( baseclasses_view->selectedItem() )
00545     {
00546         setAccessForBase(baseclasses_view->selectedItem()->text(0), "private");
00547         baseclasses_view->selectedItem()->setText(1, (virtual_box->isChecked()?"virtual ":"") + QString("private"));
00548     }
00549 }
00550 
00551 void CppNewClassDialog::currBaseProtectedSet()
00552 {
00553     if ( baseclasses_view->selectedItem() )
00554     {
00555         setAccessForBase(baseclasses_view->selectedItem()->text(0), "protected");
00556         baseclasses_view->selectedItem()->setText(1, (virtual_box->isChecked()?"virtual ":"") + QString("protected"));
00557     }
00558 }
00559 
00560 void CppNewClassDialog::currBasePublicSet()
00561 {
00562     if ( baseclasses_view->selectedItem() )
00563     {
00564         setAccessForBase(baseclasses_view->selectedItem()->text(0), "public");
00565         baseclasses_view->selectedItem()->setText(1, (virtual_box->isChecked()?"virtual ":"") + QString("public"));
00566     }
00567 }
00568 
00569 void CppNewClassDialog::scopeboxActivated(int value)
00570 {
00571     if ( baseclasses_view->selectedItem() )
00572     {
00573         baseclasses_view->selectedItem()->setText(2, QString("%1").arg(value));
00574     }
00575 }
00576 
00577 void CppNewClassDialog::currBaseVirtualChanged(int val)
00578 {
00579     if ( baseclasses_view->selectedItem() )
00580     {
00581         baseclasses_view->selectedItem()->setText(1, QString(val?"virtual ":"") +
00582          QString(private_button->isChecked()?"private":"") +
00583          QString(protected_button->isChecked()?"protected":"") +
00584          QString(public_button->isChecked()?"public":""));
00585     }
00586 }
00587 
00588 void CppNewClassDialog::currBaseSelected(QListViewItem *it)
00589 {
00590     if (it == 0)
00591     {
00592         setStateOfInheritanceEditors(false, false);
00593         return;
00594     }
00595     setStateOfInheritanceEditors(true);
00596     basename_edit->setText(it->text(0));
00597     baseinclude_edit->setText(it->text(3));
00598     scope_box->setCurrentItem(it->text(2).toInt());
00599     if (it->text(1).contains("private"))
00600         private_button->setChecked(true);
00601     else
00602         private_button->setChecked(false);
00603     if (it->text(1).contains("protected"))
00604         protected_button->setChecked(true);
00605     else
00606         protected_button->setChecked(false);
00607     if (it->text(1).contains("public"))
00608         public_button->setChecked(true);
00609     else
00610         public_button->setChecked(false);
00611     if (it->text(1).contains("virtual"))
00612         virtual_box->setChecked(true);
00613     else
00614         virtual_box->setChecked(false);
00615     checkUpButtonState();
00616     checkDownButtonState();
00617     
00618     if ( it->text(4) == "true" )
00619         baseincludeModified = true;
00620     else
00621         baseincludeModified = false;
00622 }
00623 
00624 void CppNewClassDialog::upbaseclass_button_clicked()
00625 {
00626     bool basename_focused = false;
00627     if (basename_edit->hasFocus())
00628     {
00629         basename_focused = true;
00630         basename_edit->clearFocus();
00631     }
00632     if (baseclasses_view->selectedItem())
00633     {
00634         QListViewItem *it = baseclasses_view->selectedItem();
00635         if (it->itemAbove())
00636         {
00637             QListViewItem *newit;
00638             if (it->itemAbove()->itemAbove())
00639                 newit = new QListViewItem(baseclasses_view, it->itemAbove()->itemAbove(),
00640                     it->text(0), it->text(1), it->text(2), it->text(3), it->text(4));
00641             else
00642                 newit = new QListViewItem(baseclasses_view, it->text(0), it->text(1), 
00643                     it->text(2), it->text(3), it->text(4));
00644             remBaseClassOnly();
00645             baseclasses_view->setSelected(newit, true);
00646             checkUpButtonState();
00647             updateConstructorsOrder();
00648         }
00649     }
00650     if (basename_focused)
00651         basename_edit->setFocus();
00652 }
00653 
00654 void CppNewClassDialog::downbaseclass_button_clicked()
00655 {
00656     bool basename_focused = false;
00657     if (basename_edit->hasFocus())
00658     {
00659         basename_focused = true;
00660         basename_edit->clearFocus();
00661     }
00662     if (baseclasses_view->selectedItem())
00663     {
00664         QListViewItem *it = baseclasses_view->selectedItem();
00665         if (it->itemBelow())
00666         {
00667             QListViewItem *newit = new QListViewItem(baseclasses_view, it->itemBelow(),
00668                 it->text(0), it->text(1), it->text(2), it->text(3), it->text(3));
00669             remBaseClassOnly();
00670             baseclasses_view->setSelected(newit, true);
00671             setStateOfInheritanceEditors(true);
00672             checkDownButtonState();
00673             updateConstructorsOrder();
00674         }
00675     }
00676     if (basename_focused)
00677         basename_edit->setFocus();
00678 }
00679 
00680 void CppNewClassDialog::updateConstructorsOrder()
00681 {
00682     QListViewItemIterator it( baseclasses_view );
00683     QListViewItem *c_it;
00684     QListViewItem *fc_it = 0;
00685 
00686     while ( it.current() )
00687     {
00688         if ( (c_it = constructors_view->findItem(it.current()->text(0), 0)) )
00689         {
00690             c_it->moveItem(fc_it);
00691             fc_it = c_it;
00692         }
00693         ++it;
00694     }
00695 }
00696 
00697 
00698 void CppNewClassDialog::checkUpButtonState()
00699 {
00700     if (baseclasses_view->selectedItem())
00701         upbaseclass_button->setEnabled(baseclasses_view->selectedItem()->itemAbove());
00702 }
00703 
00704 void CppNewClassDialog::checkDownButtonState()
00705 {
00706     if (baseclasses_view->selectedItem())
00707         downbaseclass_button->setEnabled(baseclasses_view->selectedItem()->itemBelow());
00708 }
00709 
00710 void CppNewClassDialog::baseclasses_view_selectionChanged()
00711 {
00712 /*    if (baseclasses_view->selectedItem())
00713     {
00714         setStateOfInheritanceEditors(false, false);
00715     }*/
00716 }
00717 
00718 void CppNewClassDialog::changeToPrivate()
00719 {
00720     if (access_view->selectedItem())
00721         access_view->selectedItem()->setText(2, "private");
00722 }
00723 
00724 void CppNewClassDialog::changeToProtected()
00725 {
00726     if (access_view->selectedItem())
00727         access_view->selectedItem()->setText(2, "protected");
00728 }
00729 
00730 void CppNewClassDialog::changeToPublic()
00731 {
00732     if (access_view->selectedItem())
00733         access_view->selectedItem()->setText(2, "public");
00734 }
00735 
00736 void CppNewClassDialog::changeToInherited()
00737 {
00738     if (access_view->selectedItem())
00739         access_view->selectedItem()->setText(2, QString::null);
00740 }
00741 
00742 void CppNewClassDialog::newTabSelected(const QString& /*text*/)
00743 {
00744 /*    if (text == i18n("&Advanced Inheritance"))
00745         reloadAdvancedInheritance(true);*/
00746 }
00747 
00748 void CppNewClassDialog::newTabSelected(QWidget* /*w*/)
00749 {
00750 /*    if ( QString(w->name()) == QString("tab2"))
00751     {
00752         reloadAdvancedInheritance(false);
00753     }*/
00754 }
00755 
00756 
00757 void CppNewClassDialog::reloadAdvancedInheritance(bool clean)
00758 {
00759     clearConstructorsList(clean);
00760     clearMethodsList(clean);
00761     clearUpgradeList(clean);
00762 
00763     QListViewItemIterator it( baseclasses_view );
00764     while ( it.current() )
00765     {
00766         if (! (it.current()->text(0).isEmpty()) )
00767         {
00768             parseClass(it.current()->text(0), it.current()->text(1));
00769         }
00770         ++it;
00771     }
00772 }
00773 
00774 void CppNewClassDialog::parseClass(QString clName, QString inheritance)
00775 {
00776     // Determine namespace
00777     QStringList clNamespace = currNamespace;
00778     bool clFullQualified = false;
00779     
00780     if(clName.contains("::")) {
00781     // Full qualified, override imported namespace
00782     clFullQualified = true;
00783     int splitpoint = clName.findRev("::");
00784     clNamespace = QStringList::split("::", clName.left(splitpoint));
00785     clName = clName.mid(splitpoint + 2);
00786     }
00787   
00788     kdDebug(9007) << "clFullQualified = " << clFullQualified << endl;
00789     kdDebug(9007) << "clName = " << clName << endl;
00790     QString debMsg = "clNamespace = ";
00791     for(QStringList::const_iterator it = clNamespace.begin();
00792     it != clNamespace.end(); ++it)
00793     debMsg += (*it) + "::";
00794     kdDebug(9007) << debMsg << endl;
00795   
00796     QString templateAdd = templateActualParamsFormatted(clName);
00797     removeTemplateParams(clName);
00798 
00799     ClassList myClasses; // = m_part->codeModel()->globalNamespace()->classByName(clName);
00800 
00801     NamespaceDom namespaceDom = m_part->codeModel()->globalNamespace();
00802 
00803     QStringList::const_iterator namespaceIt = clNamespace.begin();
00804     for( ; namespaceIt != clNamespace.end(); ++namespaceIt) {
00805     if (! namespaceDom -> hasNamespace(*namespaceIt))
00806         break;
00807     namespaceDom = namespaceDom->namespaceByName(*namespaceIt);
00808     }
00809     if (namespaceIt == clNamespace.end()) {
00810     // Found specified namespace
00811     myClasses = namespaceDom->classByName(clName);
00812     // Fall back to global namespace if class was not fully qualified and is not found in selected namespace
00813     if( myClasses.empty() && ! clFullQualified )
00814         myClasses = m_part -> codeModel() -> globalNamespace() -> classByName(clName);
00815     }
00816     
00817     for (ClassList::const_iterator classIt = myClasses.begin(); classIt != myClasses.end(); ++classIt)
00818     {
00819         PCheckListItem<ClassDom> *it = new PCheckListItem<ClassDom>(*classIt, constructors_view, (*classIt)->name());
00820         it->templateAddition = templateAdd;
00821         PListViewItem<ClassDom> *over = new PListViewItem<ClassDom>(*classIt, methods_view, (*classIt)->name());
00822         over->templateAddition = templateAdd;
00823         QListViewItem *over_methods = new QListViewItem(over, i18n("Methods"));
00824         QListViewItem *over_slots = new QListViewItem(over, i18n("Slots (Qt-specific)"));
00825         PListViewItem<ClassDom> *access = new PListViewItem<ClassDom>(*classIt, access_view, (*classIt)->name());
00826         QListViewItem *access_methods = new QListViewItem(access, i18n("Methods"));
00827         QListViewItem *access_slots = new QListViewItem(access, i18n("Slots (Qt-specific)"));
00828         QListViewItem *access_attrs = new QListViewItem(access, i18n("Attributes"));
00829 
00830         FunctionList functionList = (*classIt)->functionList();
00831         for (FunctionList::const_iterator methodIt = functionList.begin();
00832             methodIt != functionList.end(); ++methodIt)
00833         {
00834             if ( (*methodIt)->isSignal() )
00835             {
00836                 // don't show signals as overridable methods
00837             }
00838             else if (isConstructor((*classIt)->name(), *methodIt))
00839             {
00840                 addToConstructorsList(it, *methodIt);
00841             }
00842             else if ((*methodIt)->isSlot())
00843             {
00844                 if ((*methodIt)->access() != CodeModelItem::Private)
00845                 {
00846             addToMethodsList(over_slots, *methodIt);
00847 
00848                     QString inhModifier;
00849                     //protected inheritance gives protected attributes
00850                     if (inheritance.contains("protected")) inhModifier = "protected";
00851                     //private inheritance gives private attributes
00852                     else if (inheritance.contains("private")) inhModifier = "private";
00853                     //public inheritance gives protected and public attributes
00854                     else if (inheritance.contains("public")) inhModifier = (*methodIt)->access() == CodeModelItem::Public ? "public" : "protected";
00855                     addToUpgradeList(access_slots, *methodIt, inhModifier );
00856                 }
00857             }
00858             else
00859             {
00860                 // display only public and protected methods of the base class
00861                 if ( (!isDestructor((*classIt)->name(), *methodIt)) && ((*methodIt)->access() != CodeModelItem::Private) )
00862                 {
00863                     addToMethodsList(over_methods, *methodIt);
00864             
00865                     // see what modifier is given for the base class
00866                     QString inhModifier;
00867                     //protected inheritance gives protected methods
00868                     if (inheritance.contains("protected")) inhModifier = "protected";
00869                     //private inheritance gives private methods
00870                     else if (inheritance.contains("private")) inhModifier = "private";
00871                     //public inheritance gives protected and public methods
00872                     else if (inheritance.contains("public")) inhModifier = (*methodIt)->access() == CodeModelItem::Public ? "public" : "protected";
00873                     addToUpgradeList(access_methods, *methodIt, inhModifier );
00874                 }
00875             }
00876         }
00877 
00878         VariableList variableList = (*classIt)->variableList();
00879         for (VariableList::const_iterator varIt = variableList.begin();
00880             varIt != variableList.end(); ++varIt)
00881         {
00882             if ((*varIt)->access() != CodeModelItem::Private)
00883             {
00884                 QString inhModifier;
00885                 //protected inheritance gives protected attributes
00886                 if (inheritance.contains("protected")) inhModifier = "protected";
00887                 //private inheritance gives private attributes
00888                 else if (inheritance.contains("private")) inhModifier = "private";
00889                 //public inheritance gives protected and public attributes
00890                 else if (inheritance.contains("public")) inhModifier = (*varIt)->access() == CodeModelItem::Public ? "public" : "protected";
00891                 addToUpgradeList(access_attrs, *varIt, inhModifier );
00892             }
00893         }
00894     }
00895 }
00896 
00897 bool CppNewClassDialog::isConstructor(QString className, const FunctionDom &method)
00898 {
00899 //  regexp:  myclass\\s*\\(\\s*(const)?\\s*myclass\\s*&[A-Za-z_0-9\\s]*\\) is for copy constructors
00900     if ( (className == method->name()) )
00901     {
00902         qWarning("1x");
00903         if ( (method->argumentList().count() == 1) && (m_part->formatModelItem(method->argumentList()[0].data()).contains(QRegExp(" *(const)? *" + className + " *& *"))) )
00904 //        if ( method->asString().contains(QRegExp(className + "\\s*\\(\\s*(const)?\\s*" + className + "\\s*&[A-Za-z_0-9\\s]*\\)", true, false)) )
00905             return false;
00906         else
00907             return true;
00908     }
00909     else
00910         return false;
00911 }
00912 
00913 void CppNewClassDialog::addToConstructorsList(QCheckListItem *myClass, FunctionDom method)
00914 {
00915     new PCheckListItem<FunctionDom>(method, myClass, m_part->formatModelItem(method.data()), QCheckListItem::RadioButton);
00916 }
00917 
00918 void CppNewClassDialog::addToMethodsList(QListViewItem *parent, FunctionDom method)
00919 {
00920     PCheckListItem<FunctionDom> *it = new PCheckListItem<FunctionDom>(method, parent, m_part->formatModelItem(method.data()), QCheckListItem::CheckBox);
00921     it->setText(1, i18n("extend"));
00922 }
00923 
00924 void CppNewClassDialog::addToUpgradeList(QListViewItem *parent, FunctionDom method, QString modifier)
00925 {
00926     PListViewItem<FunctionDom> *it = new PListViewItem<FunctionDom>(method, parent, m_part->formatModelItem(method.data()));
00927     it->setText(1, modifier);
00928 }
00929 
00930 void CppNewClassDialog::addToUpgradeList(QListViewItem *parent, VariableDom attr, QString modifier)
00931 {
00932     PListViewItem<VariableDom> *it = new PListViewItem<VariableDom>(attr, parent, m_part->formatModelItem(attr.data()));
00933     it->setText(1, modifier);
00934 }
00935 
00936 void CppNewClassDialog::clear_selection_button_clicked()
00937 {
00938     QListViewItemIterator it( constructors_view );
00939     while ( it.current() )
00940     {
00941         PCheckListItem<FunctionDom> *curr;
00942         if ( (curr = dynamic_cast<PCheckListItem<FunctionDom>* >(it.current()) ) )
00943             curr->setOn(false);
00944         ++it;
00945     }
00946 }
00947 
00948 void CppNewClassDialog::clearConstructorsList(bool clean)
00949 {
00950     if (clean)
00951         constructors_view->clear();
00952 /*    else
00953     {
00954         QListViewItemIterator it( constructors_view );
00955         while ( it.current() )
00956         {
00957             if ( ! currBaseClasses.contains(it.current().text(0)) )
00958                 delete it.current();
00959             ++it;
00960         }
00961     }*/
00962 }
00963 
00964 void CppNewClassDialog::clearMethodsList(bool clean)
00965 {
00966     if (clean)
00967         methods_view->clear();
00968 }
00969 
00970 void CppNewClassDialog::clearUpgradeList(bool clean)
00971 {
00972     if (clean)
00973         access_view->clear();
00974 }
00975 
00976 void CppNewClassDialog::setAccessForItem(QListViewItem *curr, QString newAccess, bool isPublic)
00977 {
00978     if (newAccess == "public")
00979         curr->setText(1, isPublic ? "public" : "protected");
00980     else
00981         curr->setText(1, newAccess);
00982     if (!curr->text(2).isEmpty())
00983     {
00984         if ( (curr->text(2) == "private") && ((newAccess == "public") || (newAccess == "protected")) )
00985             curr->setText(2, QString::null);
00986         if ( (curr->text(2) == "protected") && ((newAccess == "public") && (isPublic)) )
00987             curr->setText(2, QString::null);
00988     }
00989 }
00990 
00991 void CppNewClassDialog::setAccessForBase(QString baseclass, QString newAccess)
00992 {
00993     QListViewItem *base;
00994 
00995     if ( (base = access_view->findItem(baseclass, 0)) )
00996     {
00997         QListViewItemIterator it( base );
00998         while ( it.current() )
00999         {
01000             if ( !it.current()->text(1).isEmpty() )
01001             {
01002                 PListViewItem<VariableDom> *curr;
01003                 PListViewItem<FunctionDom> *curr_m;
01004                 if ( (curr = dynamic_cast<PListViewItem<VariableDom>* >(it.current())) )
01005                     setAccessForItem(curr, newAccess, curr->item()->access() == CodeModelItem::Public);
01006                 else if ( (curr_m = dynamic_cast<PListViewItem<FunctionDom>* >(it.current())) )
01007                     setAccessForItem(curr_m, newAccess, curr_m->item()->access() == CodeModelItem::Public);
01008             }
01009             ++it;
01010         }
01011     }
01012 }
01013 
01014 
01015 void CppNewClassDialog::access_view_mouseButtonPressed( int button, QListViewItem * item, const QPoint &p, int /*c*/ )
01016 {
01017     if (item && ( (button == LeftButton) || (button == RightButton)) && (item->depth() > 1) )
01018     {
01019         accessMenu->setItemEnabled(1, true );
01020         accessMenu->setItemEnabled(2, true );
01021         accessMenu->setItemEnabled(3, true );
01022         if (item->text(1) == "protected")
01023         {
01024             accessMenu->setItemEnabled(1, false);
01025         }
01026         if (item->text(1) == "public")
01027         {
01028             accessMenu->setItemEnabled(1, false);
01029             accessMenu->setItemEnabled(2, false);
01030         }
01031         accessMenu->exec(p);
01032 
01033 /*        accessMenu->setItemEnabled(1, item->text(1) == "private" ? false : true );
01034         accessMenu->setItemEnabled(2, item->text(1) == "protected" ? false : true );
01035         accessMenu->setItemEnabled(3, item->text(1) == "public" ? false : true );*/
01036     }
01037 }
01038 
01039 
01040 void CppNewClassDialog::methods_view_mouseButtonPressed(int button ,QListViewItem * item, const QPoint&p ,int /*c*/)
01041 {
01042     if (item && ( button == RightButton ) && (item->depth() > 1) && (! item->text(1).isEmpty()) )
01043     {
01044         overMenu->exec(p);
01045     }
01046 }
01047 
01048 void CppNewClassDialog::extendFunctionality()
01049 {
01050     if (methods_view->selectedItem())
01051         methods_view->selectedItem()->setText(1, i18n("extend"));
01052 }
01053 
01054 void CppNewClassDialog::replaceFunctionality()
01055 {
01056     if (methods_view->selectedItem())
01057         methods_view->selectedItem()->setText(1, i18n("replace"));
01058 }
01059 
01060 void CppNewClassDialog::selectall_button_clicked()
01061 {
01062     QListViewItemIterator it( constructors_view );
01063     while ( it.current() )
01064     {
01065         PCheckListItem<FunctionDom> *curr;
01066         if ( (curr = dynamic_cast<PCheckListItem<FunctionDom>* >(it.current()) ) )
01067             curr->setOn(true);
01068         ++it;
01069     }
01070 }
01071 
01072 void CppNewClassDialog::to_constructors_list_clicked()
01073 {
01074     QString templateAdd = templateStrFormatted().isEmpty() ? QString::null : templateStrFormatted() + "\n";
01075     QString constructor_h = classNameFormatted();
01076     QString constructor_cpp = templateAdd + classNameFormatted() + templateParamsFormatted() + "::" + classNameFormatted();
01077     constructor_h += "(";
01078     constructor_cpp += "(";
01079     QString params_h;
01080     QString params_cpp;
01081     QString base;
01082     int unnamed = 1;
01083 
01084     QListViewItemIterator it( constructors_view );
01085     while ( it.current() )
01086     {
01087         PCheckListItem<FunctionDom> *curr;
01088         if ( (curr = dynamic_cast<PCheckListItem<FunctionDom>* >(it.current())) )
01089         {
01090             if (curr->isOn() && curr->parent())
01091             {
01092                 //fill the base classes list
01093                 base += base.isEmpty() ? ": " : ", ";
01094                 base += curr->parent()->text(0);
01095                 PCheckListItem<ClassDom> *p;
01096                 if ( (p = dynamic_cast<PCheckListItem<ClassDom>* >(curr->parent())) )
01097                 {
01098                     base += p->templateAddition;
01099                 }
01100                 params_h += params_h.isEmpty() ? "" : ", ";
01101 
01102                 //fill arguments for both constructor and base class initializer
01103                 QString cparams;
01104                 QString bparams;
01105                 ArgumentList argumentList = curr->item()->argumentList();
01106                 for (ArgumentList::const_iterator argIt = argumentList.begin();
01107                     argIt != argumentList.end(); ++argIt)
01108                 {
01109                     bparams += bparams.isEmpty() ? "" : ", ";
01110                     cparams += cparams.isEmpty() ? "" : ", ";
01111                     cparams += (*argIt)->type() + " ";
01112                     if ((*argIt)->name().isEmpty())
01113                     {
01114                         cparams += QString("arg%1").arg(unnamed);
01115                         bparams += QString("arg%1").arg(unnamed++);
01116                     }
01117                     else
01118                     {
01119                         bparams += (*argIt)->name();
01120                         cparams += (*argIt)->name();
01121                     }
01122                     if (!(*argIt)->defaultValue().isEmpty())
01123                         bparams += " = " + (*argIt)->defaultValue();
01124                 }
01125                 params_h += cparams;
01126                 params_cpp = params_h;
01127                 base += "(" + bparams + ")";
01128             }
01129         }
01130         ++it;
01131     }
01132 
01133     constructor_cpp += params_cpp + ")" + base + QString("\n{\n}\n\n\n");
01134     constructor_h += params_h + ");\n\n";
01135 
01136     constructors_h_edit->append(constructor_h);
01137     constructors_cpp_edit->append(constructor_cpp);
01138 }
01139 
01140 
01141 
01142 /* ----------------------------------------------------------
01143    ----------------------------------------------------------
01144    ----------------------------------------------------------
01145    ----------------------------------------------------------
01146 
01147     class CppNewClassDialog::ClassGenerator
01148 
01149    ----------------------------------------------------------
01150    ----------------------------------------------------------
01151    ----------------------------------------------------------
01152    ---------------------------------------------------------- */
01153 
01154 
01155 bool CppNewClassDialog::ClassGenerator::validateInput()
01156 {
01157   className = dlg.classname_edit->text().simplifyWhiteSpace();
01158   QString temp = className;
01159   className.replace(QRegExp("template *<.*> *(class *)?"), "");
01160   templateStr = temp.replace(QRegExp(QRegExp_escape(className)), "");
01161   templateStr.replace(QRegExp(" *class *$"), "");
01162 
01163   templateParams = templateStr;
01164   templateParams.replace(QRegExp("^ *template *"), "");
01165   templateParams.replace(QRegExp(" *class *"), "");
01166   templateParams.simplifyWhiteSpace();
01167 
01168   if (className.isEmpty()) {
01169     KMessageBox::error(&dlg, i18n("You must enter a classname."));
01170     return false;
01171   }
01172 
01173   header = dlg.header_edit->text().simplifyWhiteSpace();
01174   if (header.isEmpty()) {
01175     KMessageBox::error(&dlg, i18n("You must enter a name for the header file."));
01176     return false;
01177   }
01178   implementation = dlg.implementation_edit->text().simplifyWhiteSpace();
01179   if (implementation.isEmpty() ){
01180     KMessageBox::error(&dlg, i18n("You must enter a name for the implementation file."));
01181     return false;
01182   }
01183 
01185   if (header.find('/') != -1 || implementation.find('/') != -1) {
01186     KMessageBox::error(&dlg, i18n("Generated files will always be added to the "
01187                   "active directory, so you must not give an "
01188                   "explicit subdirectory."));
01189     return false;
01190   }
01191 
01192   return true;
01193 }
01194 
01195 
01196 bool CppNewClassDialog::ClassGenerator::generate()
01197 {
01198   if (!validateInput())
01199     return false;
01200 
01201   project = dlg.m_part->project();
01202   subDir = project->projectDirectory() + "/";
01203   if (!project->activeDirectory().isEmpty())
01204     subDir += project->activeDirectory() + "/";
01205   headerPath = subDir + header;
01206   implementationPath = subDir + implementation;
01207 
01208   if (QFileInfo(headerPath).exists() || QFileInfo(implementationPath).exists()) {
01209     KMessageBox::error(&dlg, i18n("KDevelop is not able to add classes "
01210                     "to existing header or implementation files."));
01211     return false;
01212   }
01213 
01214   common_text();
01215 
01216   gen_implementation();
01217 
01218   gen_interface();
01219 
01220   return true;
01221 }
01222 
01223 void CppNewClassDialog::ClassGenerator::common_text()
01224 {
01225 
01226   // common
01227 
01228   namespaceStr = dlg.namespace_edit->text();
01229   namespaces = QStringList::split(QString("::"), namespaceStr);
01230 
01231   childClass = dlg.childclass_box->isChecked();
01232   objc = dlg.objc_box->isChecked();
01233   qobject = dlg.qobject_box->isChecked();
01234   gtk = dlg.gtk_box->isChecked();
01235 
01236   if ( (dlg.baseclasses_view->childCount() == 0) && childClass)
01237     new QListViewItem(dlg.baseclasses_view, "QWidget", "public");
01238   if (objc && (dlg.baseclasses_view->childCount() == 0))
01239     new QListViewItem(dlg.baseclasses_view, "NSObject", "public");
01240 
01241   if (dlg.documentation_edit->text().isEmpty() && (!dlg.gen_config->doc_box->isChecked()) )
01242     doc = "";
01243   else
01244   {
01245     doc = QString("");
01256   }
01257 
01258   if (!namespaceStr.isEmpty()) {
01259     for ( QStringList::Iterator it = namespaces.begin(); it != namespaces.end(); ++it ) {
01260         if (!namespaceBeg.isEmpty())
01261             namespaceBeg += "\n\n";
01262         if (!namespaceEnd.isEmpty())
01263             namespaceEnd += "\n\n";
01264         namespaceBeg += "namespace " + (*it) + " {";
01265         namespaceEnd += "};";
01266     }
01267   }
01268 
01269   //advanced constructor creation
01270 
01271   advConstructorsHeader = QString::null;
01272   advConstructorsSource = QString::null;
01273   if (!dlg.constructors_h_edit->text().isEmpty())
01274   {
01275       advConstructorsHeader = "    " + dlg.constructors_h_edit->text();
01276       advConstructorsHeader.replace(QRegExp("\n"), "\n    ");
01277   }
01278   if (!dlg.constructors_cpp_edit->text().isEmpty())
01279   {
01280       advConstructorsSource = dlg.constructors_cpp_edit->text();
01281   }
01282   advConstructorsHeader.replace(QRegExp("[\\n ]*$"), QString::null);
01283   advConstructorsSource.replace(QRegExp("[\\n ]*$"), QString::null);
01284 
01285   //advanced method overriding
01286 
01287   advH_public = QString::null;
01288   advH_public_slots = QString::null;
01289   advH_protected = QString::null;
01290   advH_protected_slots = QString::null;
01291   advH_private = QString::null;
01292   advH_private_slots = QString::null;
01293   advCpp = QString::null;
01294 
01295   QListViewItemIterator it( dlg.methods_view );
01296   while ( it.current() )
01297   {
01298     PCheckListItem<FunctionDom> *curr;
01299     if ( (curr = dynamic_cast<PCheckListItem<FunctionDom>* >(it.current())) )
01300     {
01301       if (curr->isOn() && (curr->parent()) && (curr->parent()->parent()))
01302       {
01303         QString *adv_h = 0;
01304         if (curr->item()->access() == CodeModelItem::Private)
01305           adv_h = curr->item()->isSlot() ? &advH_private_slots : &advH_private;
01306         if (curr->item()->access() == CodeModelItem::Protected)
01307           adv_h = curr->item()->isSlot() ? &advH_protected_slots : &advH_protected;
01308         if (curr->item()->access() == CodeModelItem::Public)
01309           adv_h = curr->item()->isSlot() ? &advH_public_slots : &advH_public;
01310 
01311 //        if (advCpp.isEmpty()) advCpp += "\n\n";
01312 
01313         QString bcName = curr->parent()->parent()->text(0);
01314         PListViewItem<ClassDom> *bc;
01315         if ( (bc = dynamic_cast<PListViewItem<ClassDom>* >(curr->parent()->parent())) )
01316         {
01317             bcName += bc->templateAddition;
01318         }
01319         genMethodDeclaration(curr->item(), className, templateStr, adv_h, &advCpp,
01320             (curr->text(1) == i18n("extend")) ? true : false, bcName);
01321       }
01322     }
01323     ++it;
01324   }
01325 
01326   //advanced access control and upgrading
01327   QListViewItemIterator ita( dlg.access_view );
01328   while ( ita.current() )
01329   {
01330     PListViewItem<VariableDom> *curr;
01331     PListViewItem<FunctionDom> *curr_m;
01332     if ( (curr = dynamic_cast<PListViewItem<VariableDom>* >(ita.current())) )
01333     {
01334         if ((!curr->text(2).isEmpty()) && (curr->parent()) && (curr->parent()->parent()) )
01335         {
01336             QString *adv_h = 0;
01337             if (curr->text(2) == "private") adv_h = &advH_private;
01338             if (curr->text(2) == "public") adv_h = &advH_public;
01339             if (curr->text(2) == "protected") adv_h = &advH_protected;
01340 
01341 /*    if ((*adv_h).isEmpty())
01342             *adv_h += "\n\n";*/
01343 
01344             *adv_h += QString("    using ") + curr->parent()->parent()->text(0) + "::"  + curr->item()->name() + ";\n";
01345         }
01346     }
01347     else if ( (curr_m = dynamic_cast<PListViewItem<FunctionDom>* >(ita.current())) )
01348     {
01349         if ((!curr_m->text(2).isEmpty())  && (curr_m->parent()) && (curr_m->parent()->parent()) )
01350         {
01351             QString *adv_h = 0;
01352             if (curr_m->text(2) == "private") adv_h = &advH_private;
01353             if (curr_m->text(2) == "public") adv_h = &advH_public;
01354             if (curr_m->text(2) == "protected") adv_h = &advH_protected;
01355 
01356 /*    if ((*adv_h).isEmpty())
01357         *adv_h += "\n\n";*/
01358 
01359             QString methodName = curr_m->item()->name();
01360             if (!methodName.contains(QRegExp("^[a-zA-z_]")))
01361                 methodName = "operator" + methodName;
01362             *adv_h += "    using " + curr_m->parent()->parent()->text(0) + "::"  + methodName + ";\n";
01363         }
01364     }
01365     ++ita;
01366   }
01367 
01368   QRegExp e("[\\n ]*$");
01369   advH_public.replace(e, QString::null);
01370   advH_public_slots.replace(e, QString::null);
01371   advH_protected.replace(e, QString::null);
01372   advH_protected_slots.replace(e, QString::null);
01373   advH_private.replace(e, QString::null);
01374   advH_private_slots.replace(e, QString::null);
01375   advCpp.replace(e, QString::null);
01376 }
01377 
01378 void CppNewClassDialog::ClassGenerator::genMethodDeclaration(FunctionDom method,
01379     QString className, QString templateStr, QString *adv_h, QString *adv_cpp, bool extend, QString baseClassName )
01380 {
01381 /*    if ((*adv_h).isEmpty())
01382         *adv_h += "\n\n";*/
01383     QString methodName = method->name();
01384     if (!methodName.contains(QRegExp("^[a-zA-z_]")))
01385         methodName = "operator" + methodName;
01386     *adv_h += "    " + (method->isVirtual() ? QString("virtual ") : QString(""))
01387         + (method->isStatic() ? QString("static ") : QString(""))
01388         + method->resultType() + " " + methodName + "(";
01389     if (!templateStr.isEmpty())
01390         *adv_cpp += templateStr + "\n";
01391     *adv_cpp += method->resultType() + " " + className + templateParams + "::" + methodName + "(";
01392 
01393     QString bparams;
01394     QString cparams;
01395     int unnamed = 1;
01396 
01397     ArgumentList argumentList = method->argumentList();
01398     for (ArgumentList::const_iterator argIt = argumentList.begin();
01399         argIt != argumentList.end(); ++argIt)
01400     {
01401         bparams += bparams.isEmpty() ? "" : ", ";
01402         cparams += cparams.isEmpty() ? "" : ", ";
01403         cparams += (*argIt)->type() + " ";
01404         if ((*argIt)->name().isEmpty())
01405         {
01406             cparams += QString("arg%1").arg(unnamed);
01407             bparams += QString("arg%1").arg(unnamed++);
01408         }
01409         else
01410         {
01411             bparams += (*argIt)->name();
01412             cparams += (*argIt)->name();
01413         }
01414         if (!(*argIt)->defaultValue().isEmpty())
01415             bparams += " " + (*argIt)->defaultValue();
01416     }
01417     *adv_h += cparams + ")" + (method->isConstant() ? " const" : "") + ";\n";
01418     *adv_cpp += cparams + ")" + (method->isConstant() ? " const" : "") + "\n{\n";
01419     if (extend)
01420         *adv_cpp += ((method->resultType() == "void") ? "    " : "    return ") +
01421                     baseClassName + "::" + methodName + "(" + bparams + ");\n";
01422     *adv_cpp += "}\n\n";
01423 }
01424 
01425 
01426 void CppNewClassDialog::ClassGenerator::gen_implementation()
01427 {
01428 
01429   // implementation
01430 
01431   QString classImpl;
01432   QFileInfo fi(implementationPath);
01433   QString module = fi.baseName();
01434   QString basefilename = fi.baseName(true);
01435 
01436   if (dlg.filetemplate_box->isChecked()) {
01437 /*    QDomDocument dom = *dlg.m_part->projectDom();
01438     if(DomUtil::readBoolEntry(dom,"/cppsupportpart/filetemplates/choosefiles",false))
01439       classImpl = FileTemplate::read(dlg.m_part, DomUtil::readEntry(dom,"/cppsupportpart/filetemplates/implementationURL",""), FileTemplate::Custom);
01440     else*/
01441       classImpl = FileTemplate::read(dlg.m_part, fi.extension(true));
01442   }
01443 
01444   classImpl.replace(QRegExp("\\$MODULE\\$"),module);
01445   classImpl.replace(QRegExp("\\$FILENAME\\$"),basefilename);
01446 
01447   if (objc) {
01448     classImpl += dlg.gen_config->objcSource();
01449   } else if (gtk)
01450   {
01451     classImpl += dlg.gen_config->gtkSource();
01452   } else {
01453     classImpl += dlg.gen_config->cppSource();
01454 /*    classImpl += QString( 
01455              "#include \"$HEADER$\"\n"
01456              "\n"
01457              "\n")
01458       + namespaceBeg
01459       + ( advConstructorsSource.isEmpty() ? QString("$CLASSNAME$::$CLASSNAME$($ARGS$)\n"
01460         "$BASEINITIALIZER$"
01461         "{\n"
01462         "}\n") : advConstructorsSource )
01463       + QString("\n"
01464         "$CLASSNAME$::~$CLASSNAME$()\n"
01465         "{\n"
01466         "}\n")
01467       + advCpp
01468       + namespaceEnd;*/
01469   }
01470 
01471   QString relPath;
01472   for (int i = implementation.findRev('/'); i != -1; i = implementation.findRev('/', --i))
01473     relPath += "../";
01474 
01475   QString constructors = (advConstructorsSource.isEmpty() ? QString("$TEMPLATESTR$\n$CLASSNAME$$TEMPLATEPARAMS$::$CLASSNAME$($ARGS$)\n"
01476     "$BASEINITIALIZER$"
01477     "{\n"
01478     "}") : advConstructorsSource)
01479     + QString("\n\n\n"
01480         "$TEMPLATESTR$\n$CLASSNAME$$TEMPLATEPARAMS$::~$CLASSNAME$()\n"
01481         "{\n"
01482         "}\n");
01483 
01484   qWarning("NEW CLASS: constructors = %s", constructors.latin1());
01485 
01486   if (childClass)
01487   {
01488     argsH = "QWidget *parent = 0, const char *name = 0";
01489     argsCpp = "QWidget *parent, const char *name";
01490   }
01491   else if (qobject)
01492   {
01493     argsH = "QObject *parent = 0, const char *name = 0";
01494     argsCpp = "QObject *parent, const char *name";
01495   }
01496   else
01497   {
01498     argsH = "";
01499     argsCpp = "";
01500   }
01501   QString baseInitializer;
01502 
01503   if (childClass && (dlg.baseclasses_view->childCount() == 0))
01504     baseInitializer = "  : QWidget(parent, name)";
01505   else if (qobject && (dlg.baseclasses_view->childCount() == 0))
01506     baseInitializer = "  : QObject(parent, name)";
01507   else if (dlg.baseclasses_view->childCount() != 0)
01508   {
01509     QListViewItemIterator it( dlg.baseclasses_view );
01510     baseInitializer += " : ";
01511     while ( it.current() )
01512     {
01513       if (!it.current()->text(0).isEmpty())
01514       {
01515         if (baseInitializer != " : ")
01516           baseInitializer += ", ";
01517         if (childClass && (baseInitializer == " : "))
01518           baseInitializer += it.current()->text(0) + "(parent, name)";
01519         else if (qobject && (baseInitializer == " : "))
01520           baseInitializer += it.current()->text(0) + "(parent, name)";
01521         else
01522           baseInitializer += it.current()->text(0) + "()";
01523       }
01524       ++it;
01525     }
01526     baseInitializer += "\n";
01527   }
01528 
01529   constructors.replace(QRegExp("\\$BASEINITIALIZER\\$"), baseInitializer);
01530   constructors.replace(QRegExp("\\$CLASSNAME\\$"), className);
01531 //  qWarning("NEW CLASS: constructors = %s", constructors.latin1());
01532   if (templateStr.isEmpty())
01533   {
01534     constructors.replace(QRegExp("\\$TEMPLATESTR\\$\\n"), "");
01535     constructors.replace(QRegExp("\\$TEMPLATEPARAMS\\$"), "");
01536   }
01537   else
01538   {
01539     constructors.replace(QRegExp("\\$TEMPLATESTR\\$"), templateStr);
01540     constructors.replace(QRegExp("\\$TEMPLATEPARAMS\\$"), templateParams);
01541     classImpl.replace(QRegExp("#include \"\\$HEADER\\$\"\\n"), "");
01542   }
01543 //  qWarning("NEW CLASS: constructors = %s", constructors.latin1());
01544   constructors.replace(QRegExp("\\$ARGS\\$"), argsCpp);
01545 //  qWarning("NEW CLASS: constructors = %s", constructors.latin1());
01546 
01547 
01548   //remove unnesessary carriadge returns
01549   QString hp = relPath+header;
01550   beautifySource(classImpl, hp, className, namespaceBeg, constructors, advCpp, namespaceEnd, implementation);
01551 
01552   classImpl.replace(QRegExp("\\$HEADER\\$"), relPath+header);
01553   classImpl.replace(QRegExp("\\$CLASSNAME\\$"), className);
01554   classImpl.replace(QRegExp("\\$NAMESPACEBEG\\$"), namespaceBeg);
01555   classImpl.replace(QRegExp("\\$CONSTRUCTORDEFINITIONS\\$"), constructors);
01556   classImpl.replace(QRegExp("\\$DEFINITIONS\\$"), advCpp);
01557   classImpl.replace(QRegExp("\\$NAMESPACEEND\\$"), namespaceEnd);
01558   classImpl.replace(QRegExp("\\$FILENAME\\$"), implementation);
01559 
01560   if ( (dlg.m_part->project()) && (childClass || qobject) && (dlg.m_part->project()->options() & KDevProject::UsesAutotoolsBuildSystem))
01561   {
01562     QString moc = header;
01563     moc.replace(QRegExp("\\..*"), ".moc");
01564     classImpl += "#include \"" + moc + "\"\n";
01565   } 
01566 
01567   if (dlg.gen_config->reformat_box->isChecked())
01568   {
01569     KDevSourceFormatter *fmt = dlg.m_part->sourceFormatter();
01570     if (fmt)
01571         classImpl = fmt->formatSource(classImpl);
01572   }
01573 
01574   kdDebug(9007) << "implementationPath = " << implementationPath << endl;
01575 
01576   QFile ifile(implementationPath);
01577   if (!ifile.open(IO_WriteOnly)) {
01578     KMessageBox::error(&dlg, i18n("Cannot write to implementation file"));
01579     return;
01580   }
01581   QTextStream istream(&ifile);
01582   istream << classImpl;
01583   ifile.close();
01584 }
01585 
01586 
01587 void CppNewClassDialog::ClassGenerator::gen_interface()
01588 {
01589   // interface
01590 
01591   QString classIntf;
01592   QFileInfo fi(headerPath);
01593   QString module = fi.baseName();
01594   QString basefilename = fi.baseName(true);
01595 
01596   if (dlg.filetemplate_box->isChecked()) {
01597 /*    QDomDocument dom = *dlg.m_part->projectDom();
01598     if(DomUtil::readBoolEntry(dom,"/cppsupportpart/filetemplates/choosefiles",false))
01599       classIntf = FileTemplate::read(dlg.m_part, DomUtil::readEntry(dom,"/cppsupportpart/filetemplates/interfaceURL",""), FileTemplate::Custom);
01600     else*/
01601       classIntf  = FileTemplate::read(dlg.m_part, fi.extension(true));
01602   }
01603 
01604   classIntf.replace(QRegExp("\\$MODULE\\$"),module);
01605   classIntf.replace(QRegExp("\\$FILENAME\\$"),basefilename);
01606 
01607   if (objc) {
01608     classIntf += dlg.gen_config->objcHeader();
01609   }
01610   else if (gtk) {
01611     classIntf += dlg.gen_config->gtkHeader();
01612   }
01613   else {
01614     classIntf += dlg.gen_config->cppHeader();
01615 /*    classIntf = QString("\n"
01616             "#ifndef $HEADERGUARD$\n"
01617             "#define $HEADERGUARD$\n"
01618             "\n"
01619             "$INCLUDEBASEHEADER$\n"
01620             "\n")
01621       + namespaceBeg
01622       + QString("class $CLASSNAME$$INHERITANCE$\n"
01623         "{\n"
01624         "$QOBJECT$"
01625         "public:\n")
01626       + ( advConstructorsHeader.isEmpty() ? QString("    $CLASSNAME$($ARGS$);\n") : advConstructorsHeader )
01627       + QString("\n    ~$CLASSNAME$();\n")
01628       + advH_public
01629       + (advH_public_slots.isEmpty() ? QString::fromLatin1("") : ("\n\npublic slots:" + advH_public_slots))
01630       + (advH_protected.isEmpty() ? QString::fromLatin1("") : ("\n\nprotected:" + advH_protected))
01631       + (advH_protected_slots.isEmpty() ? QString::fromLatin1("") : ("\n\nprotected slots:" + advH_protected_slots))
01632       + (advH_private.isEmpty() ? QString::fromLatin1("") : ("\n\nprivate:" + advH_private))
01633       + (advH_private_slots.isEmpty() ? QString::fromLatin1("") : ("\n\nprivate slots:" + advH_private_slots))
01634       + QString("};\n"
01635         "\n")
01636       + namespaceEnd
01637       +     "#endif\n";*/
01638   }
01639 
01640   QString headerGuard;
01641   switch( dlg.gen_config->defCase() ){
01642     case ClassGeneratorConfig::UpperCase:
01643         headerGuard = namespaceStr.upper() + header.upper();
01644         break;
01645     case ClassGeneratorConfig::LowerCase:
01646         headerGuard = namespaceStr.lower() + header.lower();
01647         break;
01648     case ClassGeneratorConfig::SameAsFileCase:
01649         headerGuard = dlg.header_edit->text();
01650         break;
01651     case ClassGeneratorConfig::SameAsClassCase:
01652         headerGuard = namespaceStr + header;
01653         break;
01654   }
01655   headerGuard.replace(QRegExp("\\."),"_");
01656   headerGuard.replace(QRegExp("::"),"_");
01657   QString includeBaseHeader;
01658   if (childClass && (dlg.baseclasses_view->childCount() == 0)) 
01659   {
01660     includeBaseHeader = "#include <qwidget.h>";
01661   }
01662   else if (qobject && (dlg.baseclasses_view->childCount() == 0))
01663   {
01664     includeBaseHeader = "#include <qobject.h>";
01665   }
01666 
01667   if (objc) {
01668     if (dlg.baseclasses_view->firstChild())
01669       if (dlg.baseclasses_view->firstChild()->text(0) != "NSObject")
01670         if (!dlg.baseclasses_view->firstChild()->text(3).isEmpty())
01671           includeBaseHeader = "#include "
01672               + (dlg.baseclasses_view->firstChild()->text(2).toInt() == 0 ? QString("<") : QString("\""))
01673               + dlg.baseclasses_view->firstChild()->text(3)
01674               + (dlg.baseclasses_view->firstChild()->text(2).toInt() == 0 ? QString(">") : QString("\""));
01675   } else
01676   {
01677     QListViewItemIterator it( dlg.baseclasses_view );
01678     while ( it.current() )
01679     {
01680       if (!it.current()->text(0).isEmpty())
01681         if (!it.current()->text(3).isEmpty())
01682 //          if ((!childClass) || (it.current()->text(0) != "QWidget"))
01683             includeBaseHeader += (includeBaseHeader.isEmpty() ? QString(""): QString("\n")) + QString::fromLatin1( "#include " ) +
01684               (it.current()->text(2).toInt() == 0 ? QString("<") : QString("\""))
01685               + it.current()->text(3)
01686               + (it.current()->text(2).toInt() == 0 ? QString(">") : QString("\""));
01687       ++it;
01688     }
01689   }
01690 
01691   QString author = DomUtil::readEntry(*dlg.m_part->projectDom(), "/general/author");
01692 
01693   QString inheritance;
01694   if (dlg.baseclasses_view->childCount() > 0)
01695   {
01696     inheritance += " : ";
01697 
01698     QListViewItemIterator it( dlg.baseclasses_view );
01699     while ( it.current() )
01700     {
01701       if (!it.current()->text(0).isEmpty())
01702       {
01703         if (inheritance != " : ")
01704           inheritance += ", ";
01705         if (it.current()->text(1).contains("virtual"))
01706           inheritance += "virtual ";
01707         if (it.current()->text(1).contains("public"))
01708           inheritance += "public ";
01709         if (it.current()->text(1).contains("protected"))
01710           inheritance += "protected ";
01711         if (it.current()->text(1).contains("private"))
01712           inheritance += "private ";
01713         inheritance += it.current()->text(0);
01714       }
01715       ++it;
01716     }
01717   }
01718   else if (qobject)
01719     inheritance += ": public QObject";
01720     
01721   QString constructors = QString(advConstructorsHeader.isEmpty() ?
01722     QString("    $CLASSNAME$($ARGS$);") : advConstructorsHeader )
01723     + QString("\n\n    ~$CLASSNAME$();");
01724 
01725   constructors.replace(QRegExp("\\$CLASSNAME\\$"), className);
01726   constructors.replace(QRegExp("\\$ARGS\\$"), argsH);
01727     
01728   QString qobjectStr;
01729   if (childClass || qobject)
01730     qobjectStr = "Q_OBJECT";
01731 
01732 
01733   QString baseclass;
01734   if (dlg.baseclasses_view->childCount() > 0)
01735     baseclass = dlg.baseclasses_view->firstChild()->text(0);
01736   //remove unnesessary carriadge returns
01737   beautifyHeader(classIntf, headerGuard, includeBaseHeader, author, doc, className, templateStr,
01738         baseclass, inheritance, qobjectStr, argsH,
01739         header, namespaceBeg, constructors, advH_public, advH_public_slots,
01740         advH_protected, advH_protected_slots, advH_private, advH_private_slots, namespaceEnd);
01741 
01742 
01743   classIntf.replace(QRegExp("\\$HEADERGUARD\\$"), headerGuard);
01744   classIntf.replace(QRegExp("\\$INCLUDEBASEHEADER\\$"), includeBaseHeader);
01745   classIntf.replace(QRegExp("\\$AUTHOR\\$"), author);
01746   classIntf.replace(QRegExp("\\$DOC\\$"), doc);
01747   classIntf.replace(QRegExp("\\$TEMPLATE\\$"), templateStr);
01748   classIntf.replace(QRegExp("\\$CLASSNAME\\$"), className);
01749   if (dlg.baseclasses_view->childCount() > 0)
01750     classIntf.replace(QRegExp("\\$BASECLASS\\$"), dlg.baseclasses_view->firstChild()->text(0));
01751   classIntf.replace(QRegExp("\\$INHERITANCE\\$"), inheritance);
01752   classIntf.replace(QRegExp("\\$QOBJECT\\$"), qobjectStr);
01753   classIntf.replace(QRegExp("\\$ARGS\\$"), argsH);
01754   classIntf.replace(QRegExp("\\$FILENAME\\$"), header);
01755   classIntf.replace(QRegExp("\\$NAMESPACEBEG\\$"), namespaceBeg);
01756   classIntf.replace(QRegExp("\\$CONSTRUCTORDECLARATIONS\\$"), constructors);
01757   classIntf.replace(QRegExp("\\$PUBLICDECLARATIONS\\$"), advH_public);
01758   classIntf.replace(QRegExp("\\$PUBLICSLOTS\\$"), advH_public_slots);
01759   classIntf.replace(QRegExp("\\$PROTECTEDDECLARATIONS\\$"), QString("protected:\n") + advH_protected);
01760   classIntf.replace(QRegExp("\\$PROTECTEDSLOTS\\$"), QString("protected slots:\n") + advH_protected_slots);
01761   classIntf.replace(QRegExp("\\$PRIVATEDECLARATIONS\\$"), QString("private:\n") + advH_private);
01762   classIntf.replace(QRegExp("\\$PRIVATESLOTS\\$"), QString("private slots:\n") + advH_private_slots);
01763   classIntf.replace(QRegExp("\\$NAMESPACEEND\\$"), namespaceEnd);
01764 
01765   if (!templateStr.isEmpty())
01766     classIntf.replace(QRegExp("#endif"), "#include \"" + dlg.implementation_edit->text() + "\"\n\n#endif");
01767 
01768   if (dlg.gen_config->reformat_box->isChecked())
01769   {
01770     KDevSourceFormatter *fmt = dlg.m_part->sourceFormatter();
01771     if (fmt)
01772         classIntf = fmt->formatSource(classIntf);
01773   }
01774 
01775   QFile hfile(headerPath);
01776   if (!hfile.open(IO_WriteOnly)) {
01777     KMessageBox::error(&dlg, i18n("Cannot write to header file"));
01778     return;
01779   }
01780   QTextStream hstream(&hfile);
01781   hstream << classIntf;
01782   hfile.close();
01783 
01784     QStringList fileList;
01785 
01786     fileList.append ( project->activeDirectory() + "/" + header );
01787     fileList.append ( project->activeDirectory() + "/" + implementation );
01788 
01789     project->addFiles ( fileList );
01790 }
01791 
01792 void CppNewClassDialog::ClassGenerator::beautifyHeader(QString &templ, QString &headerGuard,
01793     QString &includeBaseHeader, QString &author, QString &doc, QString &className, QString &templateStr,
01794     QString &baseclass, QString &inheritance, QString &qobjectStr, QString &args,
01795     QString &header, QString &namespaceBeg, QString &constructors, QString &advH_public, QString &advH_public_slots,
01796     QString &advH_protected, QString &advH_protected_slots, QString &advH_private, QString &advH_private_slots,
01797     QString &namespaceEnd)
01798 {
01799     if (headerGuard.isEmpty())
01800         templ.replace(QRegExp("\\$HEADERGUARD\\$[\\n ]*"), QString::null);
01801     if (includeBaseHeader.isEmpty())
01802         templ.replace(QRegExp("\\$INCLUDEBASEHEADER\\$[\\n ]*"), QString::null);
01803     if (author.isEmpty())
01804         templ.replace(QRegExp("\\$AUTHOR\\$[\\n ]*"), QString::null);
01805     if (doc.isEmpty())
01806         templ.replace(QRegExp("\\$DOC\\$[\\n ]*"), QString::null);
01807     if (className.isEmpty())
01808         templ.replace(QRegExp("\\$CLASSNAME\\$[\\n ]*"), QString::null);
01809     if (templateStr.isEmpty())
01810         templ.replace(QRegExp("\\$TEMPLATE\\$[\\n ]*"), QString::null);
01811     if (baseclass.isEmpty())
01812         templ.replace(QRegExp("\\$BASECLASS\\$[\\n ]*"), QString::null);
01813     if (inheritance.isEmpty())
01814         templ.replace(QRegExp("\\$INHERITANCE\\$[\\n ]*"), QString::null);
01815     if (qobjectStr.isEmpty())
01816         templ.replace(QRegExp("\\$QOBJECT\\$[\\n ]*"), QString::null);
01817     if (args.isEmpty())
01818         templ.replace(QRegExp("\\$ARGS\\$[\\n ]*"), QString::null);
01819     if (header.isEmpty())
01820         templ.replace(QRegExp("\\$FILENAME\\$[\\n ]*"), QString::null);
01821     if (namespaceBeg.isEmpty())
01822         templ.replace(QRegExp("\\$NAMESPACEBEG\\$[\\n ]*"), QString::null);
01823     if (constructors.isEmpty())
01824         templ.replace(QRegExp("\\$CONSTRUCTORDECLARATIONS\\$[\\n ]*"), QString::null);
01825     if (advH_public.isEmpty())
01826         templ.replace(QRegExp("\\$PUBLICDECLARATIONS\\$[\\n ]*"), QString::null);
01827     if (advH_public_slots.isEmpty())
01828         templ.replace(QRegExp("\\$PUBLICSLOTS\\$[\\n ]*"), QString::null);
01829     if (advH_protected.isEmpty())
01830         templ.replace(QRegExp("\\$PROTECTEDDECLARATIONS\\$[\\n ]*"), QString::null);
01831     if (advH_protected_slots.isEmpty())
01832         templ.replace(QRegExp("\\$PROTECTEDSLOTS\\$[\\n ]*"), QString::null);
01833     if (advH_private.isEmpty())
01834         templ.replace(QRegExp("\\$PRIVATEDECLARATIONS\\$[\\n ]*"), QString::null);
01835     if (advH_private_slots.isEmpty())
01836         templ.replace(QRegExp("\\$PRIVATESLOTS\\$[\\n ]*"), QString::null);
01837     if (namespaceEnd.isEmpty())
01838         templ.replace(QRegExp("\\$NAMESPACEEND\\$[\\n ]*"), QString::null);
01839 }    
01840     
01841 
01842 void CppNewClassDialog::ClassGenerator::beautifySource(QString &templ, QString &header, QString &className, QString &namespaceBeg,
01843     QString &constructors, QString &advCpp, QString &namespaceEnd, QString &implementation)
01844 {
01845     if (header.isEmpty())
01846         templ.replace(QRegExp("\\$HEADER\\$[\\n ]*"), QString::null);
01847     if (className.isEmpty())
01848         templ.replace(QRegExp("\\$CLASSNAME\\$[\\n ]*"), QString::null);
01849     if (namespaceBeg.isEmpty())
01850         templ.replace(QRegExp("\\$NAMESPACEBEG\\$[\\n ]*"), QString::null);
01851     if (constructors.isEmpty())
01852         templ.replace(QRegExp("\\$CONSTRUCTORDEFINITIONS\\$[\\n ]*"), QString::null);
01853     if (advCpp.isEmpty())
01854         templ.replace(QRegExp("\\$DEFINITIONS\\$[\\n ]*"), QString::null);
01855     if (namespaceEnd.isEmpty())
01856         templ.replace(QRegExp("\\$NAMESPACEEND\\$[\\n ]*"), QString::null);
01857     if (implementation.isEmpty())
01858         templ.replace(QRegExp("\\$FILENAME\\$[\\n ]*"), QString::null);
01859 }
01860 
01861 QString CppNewClassDialog::classNameFormatted( )
01862 {
01863     return classNameFormatted(classname_edit->text());
01864 }
01865 
01866 QString CppNewClassDialog::classNameFormatted(const QString &name )
01867 {
01868   QString temp = name.simplifyWhiteSpace();
01869   return temp.replace(QRegExp("template *<.*> *(class *)?"), "");
01870 }
01871 
01872 
01873 QString CppNewClassDialog::templateStrFormatted( )
01874 {
01875   return templateStrFormatted(classname_edit->text());
01876 }
01877 
01878 QString CppNewClassDialog::templateStrFormatted(const QString &name )
01879 {
01880   QString className = name.simplifyWhiteSpace();
01881   QString temp = className;
01882   className.replace(QRegExp("template *<.*> *(class *)?"), "");
01883   QString templateStr = temp.replace(QRegExp(QRegExp_escape(className)), "");
01884   templateStr.replace(QRegExp(" *class *$"), "");
01885   return templateStr;
01886 }
01887 
01888 QString CppNewClassDialog::templateParamsFormatted( )
01889 {
01890   return templateParamsFormatted( classname_edit->text() );
01891 }
01892 
01893 QString CppNewClassDialog::templateParamsFormatted( const QString &name )
01894 {
01895   QString className = name.simplifyWhiteSpace();
01896   QString temp = className;
01897   className.replace(QRegExp("template *<.*> *(class *)?"), "");
01898   QString templateStr = temp.replace(QRegExp(QRegExp_escape(className)), "");
01899   templateStr.replace(QRegExp(" *class *$"), "");
01900 
01901   QString templateParams = templateStr;
01902   templateParams.replace(QRegExp("^ *template *"), "");
01903   templateParams.replace(QRegExp(" *class *"), "");
01904   templateParams.simplifyWhiteSpace();
01905 
01906   return templateParams;
01907 }
01908 
01909 QString CppNewClassDialog::templateActualParamsFormatted( const QString & name)
01910 {
01911   QString className = name.simplifyWhiteSpace();
01912   QString temp = className;
01913   className.replace(QRegExp("<.*> *"), "");
01914   QString templateStr = temp.replace(QRegExp(QRegExp_escape(className)), "");
01915   return templateStr;
01916 }
01917 
01918 void CppNewClassDialog::removeTemplateParams( QString & name)
01919 {
01920   name.replace(QRegExp("<.*> *"), "");
01921 }
01922 
01923 bool CppNewClassDialog::isDestructor( QString className, const FunctionDom &method )
01924 {
01925     if (m_part->formatModelItem(method.data()).contains(QRegExp(" *~ *"+className)))
01926         return true;
01927     return false;
01928 }
01929 
01930 #include "cppnewclassdlg.moc"
KDE Logo
This file is part of the documentation for KDevelop Version 3.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Mar 23 00:03:45 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003