KDevelop API Documentation

languages/cpp/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, "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 includeBaseHeader = "#include " 01671 + (dlg.baseclasses_view->firstChild()->text(2).toInt() == 0 ? QString("<") : QString("\"")) 01672 + dlg.baseclasses_view->firstChild()->text(3) 01673 + (dlg.baseclasses_view->firstChild()->text(2).toInt() == 0 ? QString(">") : QString("\"")); 01674 } else 01675 { 01676 QListViewItemIterator it( dlg.baseclasses_view ); 01677 while ( it.current() ) 01678 { 01679 if (!it.current()->text(0).isEmpty()) 01680 // if ((!childClass) || (it.current()->text(0) != "QWidget")) 01681 includeBaseHeader += (includeBaseHeader.isEmpty() ? QString(""): QString("\n")) + QString::fromLatin1( "#include " ) + 01682 (it.current()->text(2).toInt() == 0 ? QString("<") : QString("\"")) 01683 + it.current()->text(3) 01684 + (it.current()->text(2).toInt() == 0 ? QString(">") : QString("\"")); 01685 ++it; 01686 } 01687 } 01688 01689 QString author = DomUtil::readEntry(*dlg.m_part->projectDom(), "/general/author"); 01690 01691 QString inheritance; 01692 if (dlg.baseclasses_view->childCount() > 0) 01693 { 01694 inheritance += " : "; 01695 01696 QListViewItemIterator it( dlg.baseclasses_view ); 01697 while ( it.current() ) 01698 { 01699 if (!it.current()->text(0).isEmpty()) 01700 { 01701 if (inheritance != " : ") 01702 inheritance += ", "; 01703 if (it.current()->text(1).contains("virtual")) 01704 inheritance += "virtual "; 01705 if (it.current()->text(1).contains("public")) 01706 inheritance += "public "; 01707 if (it.current()->text(1).contains("protected")) 01708 inheritance += "protected "; 01709 if (it.current()->text(1).contains("private")) 01710 inheritance += "private "; 01711 inheritance += it.current()->text(0); 01712 } 01713 ++it; 01714 } 01715 } 01716 else if (qobject) 01717 inheritance += ": public QObject"; 01718 01719 QString constructors = QString(advConstructorsHeader.isEmpty() ? 01720 QString(" $CLASSNAME$($ARGS$);") : advConstructorsHeader ) 01721 + QString("\n\n ~$CLASSNAME$();"); 01722 01723 constructors.replace(QRegExp("\\$CLASSNAME\\$"), className); 01724 constructors.replace(QRegExp("\\$ARGS\\$"), argsH); 01725 01726 QString qobjectStr; 01727 if (childClass || qobject) 01728 qobjectStr = "Q_OBJECT"; 01729 01730 01731 QString baseclass; 01732 if (dlg.baseclasses_view->childCount() > 0) 01733 baseclass = dlg.baseclasses_view->firstChild()->text(0); 01734 //remove unnesessary carriadge returns 01735 beautifyHeader(classIntf, headerGuard, includeBaseHeader, author, doc, className, templateStr, 01736 baseclass, inheritance, qobjectStr, argsH, 01737 header, namespaceBeg, constructors, advH_public, advH_public_slots, 01738 advH_protected, advH_protected_slots, advH_private, advH_private_slots, namespaceEnd); 01739 01740 01741 classIntf.replace(QRegExp("\\$HEADERGUARD\\$"), headerGuard); 01742 classIntf.replace(QRegExp("\\$INCLUDEBASEHEADER\\$"), includeBaseHeader); 01743 classIntf.replace(QRegExp("\\$AUTHOR\\$"), author); 01744 classIntf.replace(QRegExp("\\$DOC\\$"), doc); 01745 classIntf.replace(QRegExp("\\$TEMPLATE\\$"), templateStr); 01746 classIntf.replace(QRegExp("\\$CLASSNAME\\$"), className); 01747 if (dlg.baseclasses_view->childCount() > 0) 01748 classIntf.replace(QRegExp("\\$BASECLASS\\$"), dlg.baseclasses_view->firstChild()->text(0)); 01749 classIntf.replace(QRegExp("\\$INHERITANCE\\$"), inheritance); 01750 classIntf.replace(QRegExp("\\$QOBJECT\\$"), qobjectStr); 01751 classIntf.replace(QRegExp("\\$ARGS\\$"), argsH); 01752 classIntf.replace(QRegExp("\\$FILENAME\\$"), header); 01753 classIntf.replace(QRegExp("\\$NAMESPACEBEG\\$"), namespaceBeg); 01754 classIntf.replace(QRegExp("\\$CONSTRUCTORDECLARATIONS\\$"), constructors); 01755 classIntf.replace(QRegExp("\\$PUBLICDECLARATIONS\\$"), advH_public); 01756 classIntf.replace(QRegExp("\\$PUBLICSLOTS\\$"), advH_public_slots); 01757 classIntf.replace(QRegExp("\\$PROTECTEDDECLARATIONS\\$"), QString("protected:\n") + advH_protected); 01758 classIntf.replace(QRegExp("\\$PROTECTEDSLOTS\\$"), QString("protected slots:\n") + advH_protected_slots); 01759 classIntf.replace(QRegExp("\\$PRIVATEDECLARATIONS\\$"), QString("private:\n") + advH_private); 01760 classIntf.replace(QRegExp("\\$PRIVATESLOTS\\$"), QString("private slots:\n") + advH_private_slots); 01761 classIntf.replace(QRegExp("\\$NAMESPACEEND\\$"), namespaceEnd); 01762 01763 if (!templateStr.isEmpty()) 01764 classIntf.replace(QRegExp("#endif"), "#include \"" + dlg.implementation_edit->text() + "\"\n\n#endif"); 01765 01766 if (dlg.gen_config->reformat_box->isChecked()) 01767 { 01768 KDevSourceFormatter *fmt = dlg.m_part->sourceFormatter(); 01769 if (fmt) 01770 classIntf = fmt->formatSource(classIntf); 01771 } 01772 01773 QFile hfile(headerPath); 01774 if (!hfile.open(IO_WriteOnly)) { 01775 KMessageBox::error(&dlg, "Cannot write to header file"); 01776 return; 01777 } 01778 QTextStream hstream(&hfile); 01779 hstream << classIntf; 01780 hfile.close(); 01781 01782 QStringList fileList; 01783 01784 fileList.append ( project->activeDirectory() + "/" + header ); 01785 fileList.append ( project->activeDirectory() + "/" + implementation ); 01786 01787 project->addFiles ( fileList ); 01788 } 01789 01790 void CppNewClassDialog::ClassGenerator::beautifyHeader(QString &templ, QString &headerGuard, 01791 QString &includeBaseHeader, QString &author, QString &doc, QString &className, QString &templateStr, 01792 QString &baseclass, QString &inheritance, QString &qobjectStr, QString &args, 01793 QString &header, QString &namespaceBeg, QString &constructors, QString &advH_public, QString &advH_public_slots, 01794 QString &advH_protected, QString &advH_protected_slots, QString &advH_private, QString &advH_private_slots, 01795 QString &namespaceEnd) 01796 { 01797 if (headerGuard.isEmpty()) 01798 templ.replace(QRegExp("\\$HEADERGUARD\\$[\\n ]*"), QString::null); 01799 if (includeBaseHeader.isEmpty()) 01800 templ.replace(QRegExp("\\$INCLUDEBASEHEADER\\$[\\n ]*"), QString::null); 01801 if (author.isEmpty()) 01802 templ.replace(QRegExp("\\$AUTHOR\\$[\\n ]*"), QString::null); 01803 if (doc.isEmpty()) 01804 templ.replace(QRegExp("\\$DOC\\$[\\n ]*"), QString::null); 01805 if (className.isEmpty()) 01806 templ.replace(QRegExp("\\$CLASSNAME\\$[\\n ]*"), QString::null); 01807 if (templateStr.isEmpty()) 01808 templ.replace(QRegExp("\\$TEMPLATE\\$[\\n ]*"), QString::null); 01809 if (baseclass.isEmpty()) 01810 templ.replace(QRegExp("\\$BASECLASS\\$[\\n ]*"), QString::null); 01811 if (inheritance.isEmpty()) 01812 templ.replace(QRegExp("\\$INHERITANCE\\$[\\n ]*"), QString::null); 01813 if (qobjectStr.isEmpty()) 01814 templ.replace(QRegExp("\\$QOBJECT\\$[\\n ]*"), QString::null); 01815 if (args.isEmpty()) 01816 templ.replace(QRegExp("\\$ARGS\\$[\\n ]*"), QString::null); 01817 if (header.isEmpty()) 01818 templ.replace(QRegExp("\\$FILENAME\\$[\\n ]*"), QString::null); 01819 if (namespaceBeg.isEmpty()) 01820 templ.replace(QRegExp("\\$NAMESPACEBEG\\$[\\n ]*"), QString::null); 01821 if (constructors.isEmpty()) 01822 templ.replace(QRegExp("\\$CONSTRUCTORDECLARATIONS\\$[\\n ]*"), QString::null); 01823 if (advH_public.isEmpty()) 01824 templ.replace(QRegExp("\\$PUBLICDECLARATIONS\\$[\\n ]*"), QString::null); 01825 if (advH_public_slots.isEmpty()) 01826 templ.replace(QRegExp("\\$PUBLICSLOTS\\$[\\n ]*"), QString::null); 01827 if (advH_protected.isEmpty()) 01828 templ.replace(QRegExp("\\$PROTECTEDDECLARATIONS\\$[\\n ]*"), QString::null); 01829 if (advH_protected_slots.isEmpty()) 01830 templ.replace(QRegExp("\\$PROTECTEDSLOTS\\$[\\n ]*"), QString::null); 01831 if (advH_private.isEmpty()) 01832 templ.replace(QRegExp("\\$PRIVATEDECLARATIONS\\$[\\n ]*"), QString::null); 01833 if (advH_private_slots.isEmpty()) 01834 templ.replace(QRegExp("\\$PRIVATESLOTS\\$[\\n ]*"), QString::null); 01835 if (namespaceEnd.isEmpty()) 01836 templ.replace(QRegExp("\\$NAMESPACEEND\\$[\\n ]*"), QString::null); 01837 } 01838 01839 01840 void CppNewClassDialog::ClassGenerator::beautifySource(QString &templ, QString &header, QString &className, QString &namespaceBeg, 01841 QString &constructors, QString &advCpp, QString &namespaceEnd, QString &implementation) 01842 { 01843 if (header.isEmpty()) 01844 templ.replace(QRegExp("\\$HEADER\\$[\\n ]*"), QString::null); 01845 if (className.isEmpty()) 01846 templ.replace(QRegExp("\\$CLASSNAME\\$[\\n ]*"), QString::null); 01847 if (namespaceBeg.isEmpty()) 01848 templ.replace(QRegExp("\\$NAMESPACEBEG\\$[\\n ]*"), QString::null); 01849 if (constructors.isEmpty()) 01850 templ.replace(QRegExp("\\$CONSTRUCTORDEFINITIONS\\$[\\n ]*"), QString::null); 01851 if (advCpp.isEmpty()) 01852 templ.replace(QRegExp("\\$DEFINITIONS\\$[\\n ]*"), QString::null); 01853 if (namespaceEnd.isEmpty()) 01854 templ.replace(QRegExp("\\$NAMESPACEEND\\$[\\n ]*"), QString::null); 01855 if (implementation.isEmpty()) 01856 templ.replace(QRegExp("\\$FILENAME\\$[\\n ]*"), QString::null); 01857 } 01858 01859 QString CppNewClassDialog::classNameFormatted( ) 01860 { 01861 return classNameFormatted(classname_edit->text()); 01862 } 01863 01864 QString CppNewClassDialog::classNameFormatted(const QString &name ) 01865 { 01866 QString temp = name.simplifyWhiteSpace(); 01867 return temp.replace(QRegExp("template *<.*> *(class *)?"), ""); 01868 } 01869 01870 01871 QString CppNewClassDialog::templateStrFormatted( ) 01872 { 01873 return templateStrFormatted(classname_edit->text()); 01874 } 01875 01876 QString CppNewClassDialog::templateStrFormatted(const QString &name ) 01877 { 01878 QString className = name.simplifyWhiteSpace(); 01879 QString temp = className; 01880 className.replace(QRegExp("template *<.*> *(class *)?"), ""); 01881 QString templateStr = temp.replace(QRegExp(QRegExp_escape(className)), ""); 01882 templateStr.replace(QRegExp(" *class *$"), ""); 01883 return templateStr; 01884 } 01885 01886 QString CppNewClassDialog::templateParamsFormatted( ) 01887 { 01888 return templateParamsFormatted( classname_edit->text() ); 01889 } 01890 01891 QString CppNewClassDialog::templateParamsFormatted( const QString &name ) 01892 { 01893 QString className = name.simplifyWhiteSpace(); 01894 QString temp = className; 01895 className.replace(QRegExp("template *<.*> *(class *)?"), ""); 01896 QString templateStr = temp.replace(QRegExp(QRegExp_escape(className)), ""); 01897 templateStr.replace(QRegExp(" *class *$"), ""); 01898 01899 QString templateParams = templateStr; 01900 templateParams.replace(QRegExp("^ *template *"), ""); 01901 templateParams.replace(QRegExp(" *class *"), ""); 01902 templateParams.simplifyWhiteSpace(); 01903 01904 return templateParams; 01905 } 01906 01907 QString CppNewClassDialog::templateActualParamsFormatted( const QString & name) 01908 { 01909 QString className = name.simplifyWhiteSpace(); 01910 QString temp = className; 01911 className.replace(QRegExp("<.*> *"), ""); 01912 QString templateStr = temp.replace(QRegExp(QRegExp_escape(className)), ""); 01913 return templateStr; 01914 } 01915 01916 void CppNewClassDialog::removeTemplateParams( QString & name) 01917 { 01918 name.replace(QRegExp("<.*> *"), ""); 01919 } 01920 01921 bool CppNewClassDialog::isDestructor( QString className, const FunctionDom &method ) 01922 { 01923 if (m_part->formatModelItem(method.data()).contains(QRegExp(" *~ *"+className))) 01924 return true; 01925 return false; 01926 } 01927 01928 #include "cppnewclassdlg.moc"
KDE Logo
This file is part of the documentation for KDevelop Version 3.0.4.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Tue Oct 19 08:01:42 2004 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003