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,
"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 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
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
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"