00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017 #undef QT_NO_COMPAT
00018
00019 #include "kscoring.h"
00020 #include "kscoringeditor.h"
00021
00022 #include <kdebug.h>
00023 #include <klocale.h>
00024 #include <kcombobox.h>
00025 #include <kcolorcombo.h>
00026 #include <kiconloader.h>
00027
00028 #include <qlabel.h>
00029 #include <qpushbutton.h>
00030 #include <qlayout.h>
00031 #include <qtooltip.h>
00032 #include <qcheckbox.h>
00033 #include <qbuttongroup.h>
00034 #include <qradiobutton.h>
00035 #include <qwidgetstack.h>
00036 #include <qapplication.h>
00037 #include <qtimer.h>
00038
00039
00040 template <class T> static int setCurrentItem(T *box, const QString& s)
00041 {
00042 int cnt = box->count();
00043 for (int i=0;i<cnt;++i) {
00044 if (box->text(i) == s) {
00045 box->setCurrentItem(i);
00046 return i;
00047 }
00048 }
00049 return -1;
00050 }
00051
00052
00053
00054
00055
00056
00057
00058 SingleConditionWidget::SingleConditionWidget(KScoringManager *m,QWidget *p, const char *n)
00059 : QFrame(p,n), manager(m)
00060 {
00061 QBoxLayout *topL = new QVBoxLayout(this,5);
00062 QBoxLayout *firstRow = new QHBoxLayout(topL);
00063 neg = new QCheckBox(i18n("Not"),this);
00064 QToolTip::add(neg,i18n("Negate this condition"));
00065 firstRow->addWidget(neg);
00066 headers = new KComboBox(this);
00067 headers->insertStringList(manager->getDefaultHeaders());
00068 QToolTip::add(headers,i18n("Select the header against this condition match"));
00069 firstRow->addWidget(headers,1);
00070 matches = new KComboBox(this);
00071 matches->insertStringList(KScoringExpression::conditionNames());
00072 QToolTip::add(matches,i18n("Select the type of match"));
00073 firstRow->addWidget(matches,1);
00074 expr = new KLineEdit(this);
00075 QToolTip::add(expr,i18n("The condition for the match"));
00076
00077 expr->setMinimumWidth(fontMetrics().maxWidth()*20);
00078 topL->addWidget(expr);
00079
00080 setSizePolicy(QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Fixed));
00081 setFrameStyle(Box | Sunken);
00082 setLineWidth(1);
00083 }
00084
00085 SingleConditionWidget::~SingleConditionWidget()
00086 {}
00087
00088 void SingleConditionWidget::setCondition(KScoringExpression *e)
00089 {
00090 neg->setChecked(e->isNeg());
00091 setCurrentItem(headers,e->getHeader());
00092 setCurrentItem(matches,KScoringExpression::getNameForCondition(e->getCondition()));
00093 expr->setText(e->getExpression());
00094 }
00095
00096 KScoringExpression* SingleConditionWidget::createCondition() const
00097 {
00098 QString head = headers->currentText();
00099 QString match = matches->currentText();
00100 int condType = KScoringExpression::getConditionForName(match);
00101 match = KScoringExpression::getTypeString(condType);
00102 QString cond = expr->text();
00103 QString negs = (neg->isChecked())?"1":"0";
00104 return new KScoringExpression(head,match,cond,negs);
00105 }
00106
00107 void SingleConditionWidget::clear()
00108 {
00109 neg->setChecked(false);
00110 expr->clear();
00111 }
00112
00113
00114
00115
00116
00117
00118 ConditionEditWidget::ConditionEditWidget(KScoringManager *m, QWidget *p, const char *n)
00119 : KWidgetLister(1,8,p,n), manager(m)
00120 {
00121
00122 addWidgetAtEnd();
00123 }
00124
00125 ConditionEditWidget::~ConditionEditWidget()
00126 {}
00127
00128 QWidget* ConditionEditWidget::createWidget(QWidget *parent)
00129 {
00130 return new SingleConditionWidget(manager,parent);
00131 }
00132
00133 void ConditionEditWidget::clearWidget(QWidget *w)
00134 {
00135 Q_ASSERT( w->isA("SingleConditionWidget") );
00136 SingleConditionWidget *sw = dynamic_cast<SingleConditionWidget*>(w);
00137 if (sw)
00138 sw->clear();
00139 }
00140
00141 void ConditionEditWidget::slotEditRule(KScoringRule *rule)
00142 {
00143 KScoringRule::ScoreExprList l;
00144 if (rule) l = rule->getExpressions();
00145 if (!rule || l.count() == 0) {
00146 slotClear();
00147 } else {
00148 setNumberOfShownWidgetsTo(l.count());
00149 KScoringExpression *e = l.first();
00150 SingleConditionWidget *scw = static_cast<SingleConditionWidget*>(mWidgetList.first());
00151 while (e && scw) {
00152 scw->setCondition(e);
00153 e = l.next();
00154 scw = static_cast<SingleConditionWidget*>(mWidgetList.next());
00155 }
00156 }
00157 }
00158
00159 void ConditionEditWidget::updateRule(KScoringRule *rule)
00160 {
00161 rule->cleanExpressions();
00162 for(QWidget *w = mWidgetList.first(); w; w = mWidgetList.next()) {
00163 if (! w->isA("SingleConditionWidget")) {
00164 kdWarning(5100) << "there is a widget in ConditionEditWidget "
00165 << "which isn't a SingleConditionWidget" << endl;
00166 } else {
00167 SingleConditionWidget *saw = dynamic_cast<SingleConditionWidget*>(w);
00168 if (saw)
00169 rule->addExpression(saw->createCondition());
00170 }
00171 }
00172 }
00173
00174
00175
00176
00177
00178
00179 SingleActionWidget::SingleActionWidget(KScoringManager *m,QWidget *p, const char *n)
00180 : QWidget(p,n), notifyEditor(0), scoreEditor(0), colorEditor(0),manager(m)
00181 {
00182 QHBoxLayout *topL = new QHBoxLayout(this,0,5);
00183 types = new KComboBox(this);
00184 types->setEditable(false);
00185 topL->addWidget(types);
00186 stack = new QWidgetStack(this);
00187 topL->addWidget(stack);
00188
00189 dummyLabel = new QLabel(i18n("Select an action."), stack);
00190 stack->addWidget(dummyLabel, 0);
00191
00192
00193 int index = 1;
00194 types->insertItem(QString::null);
00195 QStringList l = ActionBase::userNames();
00196 for ( QStringList::Iterator it = l.begin(); it != l.end(); ++it ) {
00197 QString name = *it;
00198 int feature = ActionBase::getTypeForUserName(name);
00199 if (manager->hasFeature(feature)) {
00200 types->insertItem(name);
00201 QWidget *w=0;
00202 switch (feature) {
00203 case ActionBase::SETSCORE:
00204 w = scoreEditor = new KIntSpinBox(-99999,99999,1,0,10, stack);
00205 break;
00206 case ActionBase::NOTIFY:
00207 w = notifyEditor = new KLineEdit(stack);
00208 break;
00209 case ActionBase::COLOR:
00210 w = colorEditor = new KColorCombo(stack);
00211 break;
00212 }
00213 stack->addWidget(w,index++);
00214 }
00215 }
00216
00217 connect(types,SIGNAL(activated(int)),stack,SLOT(raiseWidget(int)));
00218
00219
00220 types->setCurrentItem(0);
00221 stack->raiseWidget(dummyLabel);
00222 }
00223
00224 SingleActionWidget::~SingleActionWidget()
00225 {
00226 }
00227
00228 void SingleActionWidget::setAction(ActionBase *act)
00229 {
00230 kdDebug(5100) << "SingleActionWidget::setAction()" << endl;
00231 setCurrentItem(types,ActionBase::userName(act->getType()));
00232 int index = types->currentItem();
00233 stack->raiseWidget(index);
00234 switch (act->getType()) {
00235 case ActionBase::SETSCORE:
00236 scoreEditor->setValue(act->getValueString().toInt());
00237 break;
00238 case ActionBase::NOTIFY:
00239 notifyEditor->setText(act->getValueString());
00240 break;
00241 case ActionBase::COLOR:
00242 colorEditor->setColor(QColor(act->getValueString()));
00243 break;
00244 default:
00245 kdWarning(5100) << "unknown action type in SingleActionWidget::setAction()" << endl;
00246 }
00247 }
00248
00249 ActionBase* SingleActionWidget::createAction() const
00250 {
00251
00252 if (types->currentText().isEmpty())
00253 return 0;
00254
00255 int type = ActionBase::getTypeForUserName(types->currentText());
00256 switch (type) {
00257 case ActionBase::SETSCORE:
00258 return new ActionSetScore(scoreEditor->value());
00259 case ActionBase::NOTIFY:
00260 return new ActionNotify(notifyEditor->text());
00261 case ActionBase::COLOR:
00262 return new ActionColor(colorEditor->color().name());
00263 default:
00264 kdWarning(5100) << "unknown action type in SingleActionWidget::getValue()" << endl;
00265 return 0;
00266 }
00267 }
00268
00269 void SingleActionWidget::clear()
00270 {
00271 if (scoreEditor) scoreEditor->setValue(0);
00272 if (notifyEditor) notifyEditor->clear();
00273 if (colorEditor) colorEditor->setCurrentItem(0);
00274 types->setCurrentItem(0);
00275 stack->raiseWidget(dummyLabel);
00276 }
00277
00278
00279
00280
00281
00282
00283 ActionEditWidget::ActionEditWidget(KScoringManager *m,QWidget *p, const char *n)
00284 : KWidgetLister(1,8,p,n), manager(m)
00285 {
00286
00287 addWidgetAtEnd();
00288 }
00289
00290 ActionEditWidget::~ActionEditWidget()
00291 {}
00292
00293 QWidget* ActionEditWidget::createWidget( QWidget *parent )
00294 {
00295 return new SingleActionWidget(manager,parent);
00296 }
00297
00298 void ActionEditWidget::slotEditRule(KScoringRule *rule)
00299 {
00300 KScoringRule::ActionList l;
00301 if (rule) l = rule->getActions();
00302 if (!rule || l.count() == 0) {
00303 slotClear();
00304 } else {
00305 setNumberOfShownWidgetsTo(l.count());
00306 ActionBase *act = l.first();
00307 SingleActionWidget *saw = static_cast<SingleActionWidget*>(mWidgetList.first());
00308 while (act && saw) {
00309 saw->setAction(act);
00310 act = l.next();
00311 saw = static_cast<SingleActionWidget*>(mWidgetList.next());
00312 }
00313 }
00314 }
00315
00316 void ActionEditWidget::updateRule(KScoringRule *rule)
00317 {
00318 rule->cleanActions();
00319 for(QWidget *w = mWidgetList.first(); w; w = mWidgetList.next()) {
00320 if (! w->isA("SingleActionWidget")) {
00321 kdWarning(5100) << "there is a widget in ActionEditWidget "
00322 << "which isn't a SingleActionWidget" << endl;
00323 } else {
00324 SingleActionWidget *saw = dynamic_cast<SingleActionWidget*>(w);
00325 if (saw)
00326 {
00327 ActionBase *act = saw->createAction();
00328 if (act)
00329 rule->addAction(act);
00330 }
00331 }
00332 }
00333 }
00334
00335 void ActionEditWidget::clearWidget(QWidget *w)
00336 {
00337 Q_ASSERT( w->isA("SingleActionWidget") );
00338 SingleActionWidget *sw = dynamic_cast<SingleActionWidget*>(w);
00339 if (sw)
00340 sw->clear();
00341 }
00342
00343
00344
00345
00346
00347
00348 RuleEditWidget::RuleEditWidget(KScoringManager *m,QWidget *p, const char *n)
00349 : QWidget(p,n), dirty(false), manager(m), oldRuleName(QString::null)
00350 {
00351 kdDebug(5100) << "RuleEditWidget::RuleEditWidget()" << endl;
00352 if ( !n ) setName( "RuleEditWidget" );
00353 QVBoxLayout *topLayout = new QVBoxLayout( this, 5, KDialog::spacingHint() );
00354
00355
00356 QGroupBox *groupB = new QGroupBox(i18n("Properties"),this);
00357 topLayout->addWidget(groupB);
00358 QGridLayout* groupL = new QGridLayout(groupB, 6,2, 8,5);
00359 groupL->addRowSpacing(0, fontMetrics().lineSpacing()-4);
00360
00361
00362 ruleNameEdit = new KLineEdit( groupB, "ruleNameEdit" );
00363 groupL->addWidget( ruleNameEdit, 1, 1 );
00364 QLabel *ruleNameLabel = new QLabel(ruleNameEdit, i18n("&Name:"), groupB, "ruleNameLabel");
00365 groupL->addWidget( ruleNameLabel, 1, 0 );
00366
00367
00368 groupsEdit = new KLineEdit( groupB, "groupsEdit" );
00369 groupL->addWidget( groupsEdit, 2, 1 );
00370 QLabel *groupsLabel = new QLabel(groupsEdit, i18n("&Groups:"), groupB, "groupsLabel");
00371 groupL->addWidget( groupsLabel, 2, 0 );
00372
00373 QPushButton *groupsBtn = new QPushButton(i18n("A&dd Group"), groupB);
00374 connect(groupsBtn,SIGNAL(clicked()),SLOT(slotAddGroup()));
00375 groupL->addWidget( groupsBtn, 3, 0 );
00376
00377 groupsBox = new KComboBox( false, groupB, "groupsBox" );
00378 groupsBox->setDuplicatesEnabled(false);
00379 groupsBox->insertStringList(manager->getGroups());
00380 groupsBox->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
00381 groupL->addWidget( groupsBox, 3, 1 );
00382
00383
00384 expireCheck = new QCheckBox(i18n("&Expire rule automatically"), groupB);
00385 groupL->addMultiCellWidget( expireCheck, 4,4, 0,1 );
00386 expireEdit = new KIntSpinBox(1,99999,1,30,10, groupB, "expireWidget");
00387 expireEdit->setSuffix(i18n(" days"));
00388 groupL->addWidget( expireEdit, 5, 1 );
00389 expireLabel = new QLabel(expireEdit, i18n("&Rule is valid for:"), groupB, "expireLabel");
00390 groupL->addWidget( expireLabel, 5, 0 );
00391 expireLabel->setEnabled(false);
00392 expireEdit->setEnabled(false);
00393
00394 connect(expireCheck, SIGNAL(toggled(bool)), expireLabel, SLOT(setEnabled(bool)));
00395 connect(expireCheck, SIGNAL(toggled(bool)), expireEdit, SLOT(setEnabled(bool)));
00396
00397
00398 QGroupBox *groupConds = new QGroupBox(i18n("Conditions"), this);
00399 topLayout->addWidget(groupConds);
00400 QGridLayout *condL = new QGridLayout(groupConds, 3,2, 8,5);
00401
00402 condL->addRowSpacing(0, fontMetrics().lineSpacing()-4);
00403
00404 QButtonGroup *buttonGroup = new QButtonGroup(groupConds);
00405 buttonGroup->hide();
00406 linkModeAnd = new QRadioButton(i18n("Match a&ll conditions"), groupConds);
00407 buttonGroup->insert(linkModeAnd);
00408 condL->addWidget(linkModeAnd, 1,0);
00409 linkModeOr = new QRadioButton(i18n("Matc&h any condition"), groupConds);
00410 buttonGroup->insert(linkModeOr);
00411 condL->addWidget(linkModeOr, 1,1);
00412 linkModeAnd->setChecked(true);
00413
00414 condEditor = new ConditionEditWidget(manager,groupConds);
00415 condL->addMultiCellWidget(condEditor, 2,2, 0,1);
00416 connect(condEditor,SIGNAL(widgetRemoved()),this,SLOT(slotShrink()));
00417
00418
00419 QGroupBox *groupActions = new QGroupBox(i18n("Actions"), this);
00420 topLayout->addWidget(groupActions);
00421 QBoxLayout *actionL = new QVBoxLayout(groupActions,8,5);
00422 actionL->addSpacing(fontMetrics().lineSpacing()-4);
00423 actionEditor = new ActionEditWidget(manager,groupActions);
00424 actionL->addWidget(actionEditor);
00425 connect(actionEditor,SIGNAL(widgetRemoved()),this,SLOT(slotShrink()));
00426
00427 topLayout->addStretch(1);
00428
00429 kdDebug(5100) << "constructed RuleEditWidget" << endl;
00430 }
00431
00432 RuleEditWidget::~RuleEditWidget()
00433 {
00434 }
00435
00436 void RuleEditWidget::slotEditRule(const QString& ruleName)
00437 {
00438 kdDebug(5100) << "RuleEditWidget::slotEditRule(" << ruleName << ")" << endl;
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450 KScoringRule* rule = manager->findRule(ruleName);
00451 if (!rule) {
00452 kdDebug(5100) << "no rule for ruleName " << ruleName << endl;
00453 clearContents();
00454 return;
00455 }
00456 oldRuleName = rule->getName();
00457 ruleNameEdit->setText(rule->getName());
00458 groupsEdit->setText(rule->getGroups().join(";"));
00459
00460 bool b = rule->getExpireDate().isValid();
00461 expireCheck->setChecked(b);
00462 expireEdit->setEnabled(b);
00463 expireLabel->setEnabled(b);
00464 if (b)
00465 expireEdit->setValue(QDate::currentDate().daysTo(rule->getExpireDate()));
00466 else
00467 expireEdit->setValue(30);
00468 if (rule->getLinkMode() == KScoringRule::AND) {
00469 linkModeAnd->setChecked(true);
00470 }
00471 else {
00472 linkModeOr->setChecked(true);
00473 }
00474
00475 condEditor->slotEditRule(rule);
00476 actionEditor->slotEditRule(rule);
00477
00478 kdDebug(5100) << "RuleEditWidget::slotEditRule() ready" << endl;
00479 }
00480
00481 void RuleEditWidget::clearContents()
00482 {
00483 ruleNameEdit->setText("");
00484 groupsEdit->setText("");
00485 expireCheck->setChecked(false);
00486 expireEdit->setValue(30);
00487 expireEdit->setEnabled(false);
00488 condEditor->slotEditRule(0);
00489 actionEditor->slotEditRule(0);
00490 oldRuleName = QString::null;
00491 }
00492
00493 void RuleEditWidget::updateRule(KScoringRule *rule)
00494 {
00495 oldRuleName = QString::null;
00496 QString groups = groupsEdit->text();
00497 if (groups.isEmpty())
00498 rule->setGroups(QStringList(".*"));
00499 else
00500 rule->setGroups(QStringList::split(";",groups));
00501 bool b = expireCheck->isChecked();
00502 if (b)
00503 rule->setExpireDate(QDate::currentDate().addDays(expireEdit->value()));
00504 else
00505 rule->setExpireDate(QDate());
00506 actionEditor->updateRule(rule);
00507 rule->setLinkMode(linkModeAnd->isChecked()?KScoringRule::AND:KScoringRule::OR);
00508 condEditor->updateRule(rule);
00509 if (rule->getName() != ruleNameEdit->text())
00510 manager->setRuleName(rule,ruleNameEdit->text());
00511 }
00512
00513 void RuleEditWidget::updateRule()
00514 {
00515 KScoringRule *rule = manager->findRule(oldRuleName);
00516 if (rule) updateRule(rule);
00517 }
00518
00519 void RuleEditWidget::slotAddGroup()
00520 {
00521 QString grp = groupsBox->currentText();
00522 if ( grp.isEmpty() )
00523 return;
00524 QString txt = groupsEdit->text().stripWhiteSpace();
00525 if (txt == ".*") groupsEdit->setText(grp);
00526 else groupsEdit->setText(txt + ";" + grp);
00527 }
00528
00529 void RuleEditWidget::setDirty()
00530 {
00531 kdDebug(5100) << "RuleEditWidget::setDirty()" << endl;
00532 if (dirty) return;
00533 dirty = true;
00534 }
00535
00536 void RuleEditWidget::slotShrink()
00537 {
00538 emit(shrink());
00539 }
00540
00541
00542
00543
00544
00545
00546 RuleListWidget::RuleListWidget(KScoringManager *m, bool standalone, QWidget *p, const char *n)
00547 : QWidget(p,n), alone(standalone), manager(m)
00548 {
00549 kdDebug(5100) << "RuleListWidget::RuleListWidget()" << endl;
00550 if (!n) setName("RuleListWidget");
00551 QVBoxLayout *topL = new QVBoxLayout(this,standalone? 0:5,KDialog::spacingHint());
00552 ruleList = new KListBox(this);
00553 if (standalone) {
00554 connect(ruleList,SIGNAL(doubleClicked(QListBoxItem*)),
00555 this,SLOT(slotEditRule(QListBoxItem*)));
00556 connect(ruleList,SIGNAL(returnPressed(QListBoxItem*)),
00557 this,SLOT(slotEditRule(QListBoxItem*)));
00558 }
00559 connect(ruleList, SIGNAL(currentChanged(QListBoxItem*)),
00560 this, SLOT(slotRuleSelected(QListBoxItem*)));
00561 topL->addWidget(ruleList);
00562 updateRuleList();
00563 QHBoxLayout *btnL = new QHBoxLayout(topL,KDialog::spacingHint());
00564
00565 editRule=0L;
00566 newRule = new QPushButton(this);
00567 newRule->setPixmap( BarIcon( "filenew", KIcon::SizeSmall ) );
00568 QToolTip::add(newRule,i18n("New rule")),
00569 btnL->addWidget(newRule);
00570 connect(newRule, SIGNAL(clicked()), this, SLOT(slotNewRule()));
00571
00572 if (standalone) {
00573 editRule = new QPushButton(this);
00574 editRule->setPixmap( BarIcon("edit", KIcon::SizeSmall) );
00575 QToolTip::add(editRule,i18n("Edit rule"));
00576 btnL->addWidget(editRule);
00577 connect(editRule,SIGNAL(clicked()),this,SLOT(slotEditRule()));
00578 }
00579 delRule = new QPushButton(this);
00580 delRule->setPixmap( BarIcon( "editdelete", KIcon::SizeSmall ) );
00581 QToolTip::add(delRule,i18n("Remove rule"));
00582 btnL->addWidget(delRule);
00583 connect(delRule, SIGNAL(clicked()), this, SLOT(slotDelRule()));
00584 copyRule = new QPushButton(this);
00585 copyRule->setPixmap(BarIcon("editcopy", KIcon::SizeSmall));
00586 QToolTip::add(copyRule,i18n("Copy rule"));
00587 btnL->addWidget(copyRule);
00588 connect(copyRule, SIGNAL(clicked()), this, SLOT(slotCopyRule()));
00589
00590
00591 QBoxLayout *filterL = new QVBoxLayout(topL,KDialog::spacingHint());
00592 KComboBox *filterBox = new KComboBox(this);
00593 QStringList l = m->getGroups();
00594 filterBox->insertItem(i18n("<all groups>"));
00595 filterBox->insertStringList(l);
00596 filterBox->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
00597 connect(filterBox,SIGNAL(activated(const QString&)),
00598 this,SLOT(slotGroupFilter(const QString&)));
00599 slotGroupFilter(i18n("<all groups>"));
00600 QLabel *lab = new QLabel(filterBox,i18n("Sho&w only rules for group:"),this);
00601 filterL->addWidget(lab);
00602 filterL->addWidget(filterBox);
00603
00604 connect(manager,SIGNAL(changedRules()),
00605 this,SLOT(updateRuleList()));
00606 connect(manager,SIGNAL(changedRuleName(const QString&,const QString&)),
00607 this,SLOT(slotRuleNameChanged(const QString&,const QString&)));
00608 updateButton();
00609 }
00610
00611 RuleListWidget::~RuleListWidget()
00612 {
00613 }
00614
00615 void RuleListWidget::updateButton()
00616 {
00617 bool state=ruleList->count()>0;
00618 if(editRule)
00619 editRule->setEnabled(state);
00620 delRule->setEnabled(state);
00621 copyRule->setEnabled(state);
00622 }
00623
00624 void RuleListWidget::updateRuleList()
00625 {
00626 emit leavingRule();
00627 kdDebug(5100) << "RuleListWidget::updateRuleList()" << endl;
00628 QString curr = ruleList->currentText();
00629 ruleList->clear();
00630 if (group == i18n("<all groups>")) {
00631 QStringList l = manager->getRuleNames();
00632 ruleList->insertStringList(l);
00633 } else {
00634 KScoringManager::ScoringRuleList l = manager->getAllRules();
00635 for (KScoringRule* rule = l.first(); rule; rule = l.next() ) {
00636 if (rule->matchGroup(group)) ruleList->insertItem(rule->getName());
00637 }
00638 }
00639 int index = setCurrentItem(ruleList,curr);
00640 if (index <0) {
00641 ruleList->setCurrentItem(0);
00642 slotRuleSelected(ruleList->currentText());
00643 }
00644 else {
00645 slotRuleSelected(curr);
00646 }
00647 }
00648
00649 void RuleListWidget::updateRuleList(const KScoringRule *rule)
00650 {
00651 kdDebug(5100) << "RuleListWidget::updateRuleList(" << rule->getName() << ")" << endl;
00652 QString name = rule->getName();
00653 updateRuleList();
00654 slotRuleSelected(name);
00655 }
00656
00657 void RuleListWidget::slotRuleNameChanged(const QString& oldName, const QString& newName)
00658 {
00659 int ind = ruleList->currentItem();
00660 for (uint i=0;i<ruleList->count();++i)
00661 if (ruleList->text(i) == oldName) {
00662 ruleList->changeItem(newName,i);
00663 ruleList->setCurrentItem(ind);
00664 return;
00665 }
00666 }
00667
00668 void RuleListWidget::slotEditRule(const QString& s)
00669 {
00670 emit ruleEdited(s);
00671 }
00672
00673 void RuleListWidget::slotEditRule()
00674 {
00675 if (ruleList->currentItem() >= 0) {
00676 emit ruleEdited(ruleList->currentText());
00677 }
00678 else if (ruleList->count() == 0)
00679 emit ruleEdited(QString::null);
00680 }
00681
00682 void RuleListWidget::slotEditRule(QListBoxItem* item)
00683 {
00684 slotEditRule(item->text());
00685 }
00686
00687 void RuleListWidget::slotGroupFilter(const QString& s)
00688 {
00689 group = s;
00690 updateRuleList();
00691 }
00692
00693 void RuleListWidget::slotRuleSelected(const QString& ruleName)
00694 {
00695 emit leavingRule();
00696 kdDebug(5100) << "RuleListWidget::slotRuleSelected(" << ruleName << ")" << endl;
00697 if (ruleName != ruleList->currentText()) {
00698 setCurrentItem(ruleList,ruleName);
00699 }
00700 emit ruleSelected(ruleName);
00701 }
00702
00703 void RuleListWidget::slotRuleSelected(QListBoxItem *item)
00704 {
00705 if (!item) return;
00706 QString ruleName = item->text();
00707 slotRuleSelected(ruleName);
00708 }
00709
00710 void RuleListWidget::slotRuleSelected(int index)
00711 {
00712 uint idx = index;
00713 if (idx >= ruleList->count()) return;
00714 QString ruleName = ruleList->text(index);
00715 slotRuleSelected(ruleName);
00716 updateButton();
00717 }
00718
00719 void RuleListWidget::slotNewRule()
00720 {
00721 emit leavingRule();
00722 KScoringRule *rule = manager->addRule();
00723 updateRuleList(rule);
00724 if (alone) slotEditRule(rule->getName());
00725 updateButton();
00726 }
00727
00728 void RuleListWidget::slotDelRule()
00729 {
00730 KScoringRule *rule = manager->findRule(ruleList->currentText());
00731 if (rule)
00732 manager->deleteRule(rule);
00733
00734 if (!alone) slotEditRule();
00735 updateButton();
00736 }
00737
00738 void RuleListWidget::slotCopyRule()
00739 {
00740 emit leavingRule();
00741 QString ruleName = ruleList->currentText();
00742 KScoringRule *rule = manager->findRule(ruleName);
00743 if (rule) {
00744 KScoringRule *nrule = manager->copyRule(rule);
00745 updateRuleList(nrule);
00746 slotEditRule(nrule->getName());
00747 }
00748 updateButton();
00749 }
00750
00751
00752
00753
00754
00755
00756 KScoringEditor* KScoringEditor::scoreEditor = 0;
00757
00758 KScoringEditor::KScoringEditor(KScoringManager* m,
00759 QWidget *parent, const char *name)
00760 : KDialogBase(parent,name,false,i18n("Rule Editor"),Ok|Apply|Cancel,Ok,true), manager(m)
00761 {
00762 manager->pushRuleList();
00763 if (!scoreEditor) scoreEditor = this;
00764 kdDebug(5100) << "KScoringEditor::KScoringEditor()" << endl;
00765 if (!name) setName("KScoringEditor");
00766
00767
00768 QWidget *w = new QWidget(this);
00769 setMainWidget(w);
00770 QHBoxLayout *hbl = new QHBoxLayout(w,0,spacingHint());
00771 ruleLister = new RuleListWidget(manager,false,w);
00772 hbl->addWidget(ruleLister);
00773 ruleEditor = new RuleEditWidget(manager,w);
00774 hbl->addWidget(ruleEditor);
00775 connect(ruleLister,SIGNAL(ruleSelected(const QString&)),
00776 ruleEditor, SLOT(slotEditRule(const QString&)));
00777 connect(ruleLister, SIGNAL(leavingRule()),
00778 ruleEditor, SLOT(updateRule()));
00779 connect(ruleEditor, SIGNAL(shrink()), SLOT(slotShrink()));
00780 connect(this,SIGNAL(finished()),SLOT(slotFinished()));
00781 ruleLister->slotRuleSelected(0);
00782 resize(550, sizeHint().height());
00783 }
00784
00785 void KScoringEditor::setDirty()
00786 {
00787 QPushButton *applyBtn = actionButton(Apply);
00788 applyBtn->setEnabled(true);
00789 }
00790
00791 KScoringEditor::~KScoringEditor()
00792 {
00793 scoreEditor = 0;
00794 }
00795
00796 KScoringEditor* KScoringEditor::createEditor(KScoringManager* m,
00797 QWidget *parent, const char *name)
00798 {
00799 if (scoreEditor) return scoreEditor;
00800 else return new KScoringEditor(m,parent,name);
00801 }
00802
00803 void KScoringEditor::setRule(KScoringRule* r)
00804 {
00805 kdDebug(5100) << "KScoringEditor::setRule(" << r->getName() << ")" << endl;
00806 QString ruleName = r->getName();
00807 ruleLister->slotRuleSelected(ruleName);
00808 }
00809
00810 void KScoringEditor::slotShrink()
00811 {
00812 QTimer::singleShot(5, this, SLOT(slotDoShrink()));
00813 }
00814
00815 void KScoringEditor::slotDoShrink()
00816 {
00817 updateGeometry();
00818 QApplication::sendPostedEvents();
00819 resize(width(),sizeHint().height());
00820 }
00821
00822 void KScoringEditor::slotApply()
00823 {
00824 QString ruleName = ruleLister->currentRule();
00825 KScoringRule *rule = manager->findRule(ruleName);
00826 if (rule) {
00827 ruleEditor->updateRule(rule);
00828 ruleLister->updateRuleList(rule);
00829 }
00830 manager->removeTOS();
00831 manager->pushRuleList();
00832 }
00833
00834 void KScoringEditor::slotOk()
00835 {
00836 slotApply();
00837 manager->removeTOS();
00838 KDialogBase::slotOk();
00839 manager->editorReady();
00840 }
00841
00842 void KScoringEditor::slotCancel()
00843 {
00844 manager->popRuleList();
00845 KDialogBase::slotCancel();
00846 }
00847
00848 void KScoringEditor::slotFinished()
00849 {
00850 delayedDestruct();
00851 }
00852
00853
00854
00855
00856
00857
00858 KScoringEditorWidgetDialog::KScoringEditorWidgetDialog(KScoringManager *m, const QString& r, QWidget *p, const char *n)
00859 : KDialogBase(p,n,true,i18n("Edit Rule"),
00860 KDialogBase::Ok|KDialogBase::Apply|KDialogBase::Close,
00861 KDialogBase::Ok,true),
00862 manager(m), ruleName(r)
00863 {
00864 QFrame *f = makeMainWidget();
00865 QBoxLayout *topL = new QVBoxLayout(f);
00866 ruleEditor = new RuleEditWidget(manager,f);
00867 connect(ruleEditor, SIGNAL(shrink()), SLOT(slotShrink()));
00868 topL->addWidget(ruleEditor);
00869 ruleEditor->slotEditRule(ruleName);
00870 resize(0,0);
00871 }
00872
00873 void KScoringEditorWidgetDialog::slotApply()
00874 {
00875 KScoringRule *rule = manager->findRule(ruleName);
00876 if (rule) {
00877 ruleEditor->updateRule(rule);
00878 ruleName = rule->getName();
00879 }
00880 }
00881
00882 void KScoringEditorWidgetDialog::slotOk()
00883 {
00884 slotApply();
00885 KDialogBase::slotOk();
00886 }
00887
00888 void KScoringEditorWidgetDialog::slotShrink()
00889 {
00890 QTimer::singleShot(5, this, SLOT(slotDoShrink()));
00891 }
00892
00893 void KScoringEditorWidgetDialog::slotDoShrink()
00894 {
00895 updateGeometry();
00896 QApplication::sendPostedEvents();
00897 resize(width(),sizeHint().height());
00898 }
00899
00900
00901
00902
00903
00904
00905 KScoringEditorWidget::KScoringEditorWidget(KScoringManager *m,QWidget *p, const char *n)
00906 : QWidget(p,n), manager(m)
00907 {
00908 QBoxLayout *topL = new QVBoxLayout(this);
00909 ruleLister = new RuleListWidget(manager,true,this);
00910 topL->addWidget(ruleLister);
00911 connect(ruleLister,SIGNAL(ruleEdited(const QString&)),
00912 this,SLOT(slotRuleEdited(const QString &)));
00913 }
00914
00915 KScoringEditorWidget::~KScoringEditorWidget()
00916 {
00917 manager->editorReady();
00918 }
00919
00920 void KScoringEditorWidget::slotRuleEdited(const QString& ruleName)
00921 {
00922 KScoringEditorWidgetDialog dlg(manager,ruleName,this);
00923 dlg.exec();
00924 ruleLister->updateRuleList();
00925 }
00926
00927 #include "kscoringeditor.moc"