00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
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
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
00077
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
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
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
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
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
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
00302 if (header_edit->hasFocus())
00303 headerModified = true;
00304 }
00305
00306
00307 void CppNewClassDialog::implementationChanged()
00308 {
00309
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
00322
00323
00324
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
00361
00362
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
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
00513
00514
00515
00516
00517
00518
00519
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
00532
00533 remClassFromAdv(baseclasses_view->selectedItem()->text(0));
00534
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
00713
00714
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& )
00743 {
00744
00745
00746 }
00747
00748 void CppNewClassDialog::newTabSelected(QWidget* )
00749 {
00750
00751
00752
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
00777 QStringList clNamespace = currNamespace;
00778 bool clFullQualified = false;
00779
00780 if(clName.contains("::")) {
00781
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;
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
00811 myClasses = namespaceDom->classByName(clName);
00812
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
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
00850 if (inheritance.contains("protected")) inhModifier = "protected";
00851
00852 else if (inheritance.contains("private")) inhModifier = "private";
00853
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
00861 if ( (!isDestructor((*classIt)->name(), *methodIt)) && ((*methodIt)->access() != CodeModelItem::Private) )
00862 {
00863 addToMethodsList(over_methods, *methodIt);
00864
00865
00866 QString inhModifier;
00867
00868 if (inheritance.contains("protected")) inhModifier = "protected";
00869
00870 else if (inheritance.contains("private")) inhModifier = "private";
00871
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
00886 if (inheritance.contains("protected")) inhModifier = "protected";
00887
00888 else if (inheritance.contains("private")) inhModifier = "private";
00889
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
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
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
00953
00954
00955
00956
00957
00958
00959
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 )
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
01034
01035
01036 }
01037 }
01038
01039
01040 void CppNewClassDialog::methods_view_mouseButtonPressed(int button ,QListViewItem * item, const QPoint&p ,int )
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
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
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
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
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
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
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
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
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
01342
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
01357
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
01382
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
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
01438
01439
01440
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
01455
01456
01457
01458
01459
01460
01461
01462
01463
01464
01465
01466
01467
01468
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
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
01544 constructors.replace(QRegExp("\\$ARGS\\$"), argsCpp);
01545
01546
01547
01548
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
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
01598
01599
01600
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
01616
01617
01618
01619
01620
01621
01622
01623
01624
01625
01626
01627
01628
01629
01630
01631
01632
01633
01634
01635
01636
01637
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
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
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"