From 460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kmail/rulewidgethandlermanager.cpp | 1520 ++++++++++++++++++++++++++++++++++++ 1 file changed, 1520 insertions(+) create mode 100644 kmail/rulewidgethandlermanager.cpp (limited to 'kmail/rulewidgethandlermanager.cpp') diff --git a/kmail/rulewidgethandlermanager.cpp b/kmail/rulewidgethandlermanager.cpp new file mode 100644 index 000000000..c965db35b --- /dev/null +++ b/kmail/rulewidgethandlermanager.cpp @@ -0,0 +1,1520 @@ +/* -*- mode: C++; c-file-style: "gnu" -*- + rulewidgethandlermanager.cpp + + This file is part of KMail, the KDE mail client. + Copyright (c) 2004 Ingo Kloecker + + KMail is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + KMail is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include "rulewidgethandlermanager.h" + +#include "interfaces/rulewidgethandler.h" +#include "stl_util.h" + +#include +#include + +#include +#include +#include +#include +#include + +#include + +#include +using std::for_each; +using std::remove; + +KMail::RuleWidgetHandlerManager * KMail::RuleWidgetHandlerManager::self = 0; + +namespace { + class TextRuleWidgetHandler : public KMail::RuleWidgetHandler { + public: + TextRuleWidgetHandler() : KMail::RuleWidgetHandler() {} + ~TextRuleWidgetHandler() {} + + QWidget * createFunctionWidget( int number, + QWidgetStack *functionStack, + const QObject *receiver ) const; + QWidget * createValueWidget( int number, + QWidgetStack *valueStack, + const QObject *receiver ) const; + KMSearchRule::Function function( const QCString & field, + const QWidgetStack *functionStack ) const; + QString value( const QCString & field, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const; + QString prettyValue( const QCString & field, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const; + bool handlesField( const QCString & field ) const; + void reset( QWidgetStack *functionStack, + QWidgetStack *valueStack ) const; + bool setRule( QWidgetStack *functionStack, + QWidgetStack *valueStack, + const KMSearchRule *rule ) const; + bool update( const QCString & field, + QWidgetStack *functionStack, + QWidgetStack *valueStack ) const; + + private: + KMSearchRule::Function currentFunction( const QWidgetStack *functionStack ) const; + QString currentValue( const QWidgetStack *valueStack, + KMSearchRule::Function func ) const; + }; + + class MessageRuleWidgetHandler : public KMail::RuleWidgetHandler { + public: + MessageRuleWidgetHandler() : KMail::RuleWidgetHandler() {} + ~MessageRuleWidgetHandler() {} + + QWidget * createFunctionWidget( int number, + QWidgetStack *functionStack, + const QObject *receiver ) const; + QWidget * createValueWidget( int number, + QWidgetStack *valueStack, + const QObject *receiver ) const; + KMSearchRule::Function function( const QCString & field, + const QWidgetStack *functionStack ) const; + QString value( const QCString & field, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const; + QString prettyValue( const QCString & field, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const; + bool handlesField( const QCString & field ) const; + void reset( QWidgetStack *functionStack, + QWidgetStack *valueStack ) const; + bool setRule( QWidgetStack *functionStack, + QWidgetStack *valueStack, + const KMSearchRule *rule ) const; + bool update( const QCString & field, + QWidgetStack *functionStack, + QWidgetStack *valueStack ) const; + + private: + KMSearchRule::Function currentFunction( const QWidgetStack *functionStack ) const; + QString currentValue( const QWidgetStack *valueStack, + KMSearchRule::Function func ) const; + }; + + + class StatusRuleWidgetHandler : public KMail::RuleWidgetHandler { + public: + StatusRuleWidgetHandler() : KMail::RuleWidgetHandler() {} + ~StatusRuleWidgetHandler() {} + + QWidget * createFunctionWidget( int number, + QWidgetStack *functionStack, + const QObject *receiver ) const; + QWidget * createValueWidget( int number, + QWidgetStack *valueStack, + const QObject *receiver ) const; + KMSearchRule::Function function( const QCString & field, + const QWidgetStack *functionStack ) const; + QString value( const QCString & field, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const; + QString prettyValue( const QCString & field, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const; + bool handlesField( const QCString & field ) const; + void reset( QWidgetStack *functionStack, + QWidgetStack *valueStack ) const; + bool setRule( QWidgetStack *functionStack, + QWidgetStack *valueStack, + const KMSearchRule *rule ) const; + bool update( const QCString & field, + QWidgetStack *functionStack, + QWidgetStack *valueStack ) const; + + private: + KMSearchRule::Function currentFunction( const QWidgetStack *functionStack ) const; + int currentStatusValue( const QWidgetStack *valueStack ) const; + }; + + class NumericRuleWidgetHandler : public KMail::RuleWidgetHandler { + public: + NumericRuleWidgetHandler() : KMail::RuleWidgetHandler() {} + ~NumericRuleWidgetHandler() {} + + QWidget * createFunctionWidget( int number, + QWidgetStack *functionStack, + const QObject *receiver ) const; + QWidget * createValueWidget( int number, + QWidgetStack *valueStack, + const QObject *receiver ) const; + KMSearchRule::Function function( const QCString & field, + const QWidgetStack *functionStack ) const; + QString value( const QCString & field, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const; + QString prettyValue( const QCString & field, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const; + bool handlesField( const QCString & field ) const; + void reset( QWidgetStack *functionStack, + QWidgetStack *valueStack ) const; + bool setRule( QWidgetStack *functionStack, + QWidgetStack *valueStack, + const KMSearchRule *rule ) const; + bool update( const QCString & field, + QWidgetStack *functionStack, + QWidgetStack *valueStack ) const; + + private: + KMSearchRule::Function currentFunction( const QWidgetStack *functionStack ) const; + QString currentValue( const QWidgetStack *valueStack ) const; + }; +} + +KMail::RuleWidgetHandlerManager::RuleWidgetHandlerManager() +{ + registerHandler( new NumericRuleWidgetHandler() ); + registerHandler( new StatusRuleWidgetHandler() ); + registerHandler( new MessageRuleWidgetHandler() ); + // the TextRuleWidgetHandler is the fallback handler, so it has to be added + // as last handler + registerHandler( new TextRuleWidgetHandler() ); +} + +KMail::RuleWidgetHandlerManager::~RuleWidgetHandlerManager() +{ + for_each( mHandlers.begin(), mHandlers.end(), + DeleteAndSetToZero() ); +} + +void KMail::RuleWidgetHandlerManager::registerHandler( const RuleWidgetHandler * handler ) +{ + if ( !handler ) + return; + unregisterHandler( handler ); // don't produce duplicates + mHandlers.push_back( handler ); +} + +void KMail::RuleWidgetHandlerManager::unregisterHandler( const RuleWidgetHandler * handler ) +{ + // don't delete them, only remove them from the list! + mHandlers.erase( remove( mHandlers.begin(), mHandlers.end(), handler ), mHandlers.end() ); +} + +namespace { + /** Returns the number of immediate children of parent with the given object + name. Used by RuleWidgetHandlerManager::createWidgets(). + */ + int childCount( const QObject *parent, const char *objName ) + { + QObjectList *list = parent->queryList( 0, objName, false, false ); + if ( !list ) + return 0; + const int count = list->count(); + delete list; list = 0; + return count; + } +} + +void KMail::RuleWidgetHandlerManager::createWidgets( QWidgetStack *functionStack, + QWidgetStack *valueStack, + const QObject *receiver ) const +{ + for ( const_iterator it = mHandlers.begin(); it != mHandlers.end(); ++it ) { + QWidget *w = 0; + for ( int i = 0; + ( w = (*it)->createFunctionWidget( i, functionStack, receiver ) ); + ++i ) { + if ( childCount( functionStack, w->name() ) < 2 ) { + // there wasn't already a widget with this name, so add this widget + functionStack->addWidget( w ); + } + else { + // there was already a widget with this name, so discard this widget + kdDebug(5006) << "RuleWidgetHandlerManager::createWidgets: " + << w->name() << " already exists in functionStack" + << endl; + delete w; w = 0; + } + } + for ( int i = 0; + ( w = (*it)->createValueWidget( i, valueStack, receiver ) ); + ++i ) { + if ( childCount( valueStack, w->name() ) < 2 ) { + // there wasn't already a widget with this name, so add this widget + valueStack->addWidget( w ); + } + else { + // there was already a widget with this name, so discard this widget + kdDebug(5006) << "RuleWidgetHandlerManager::createWidgets: " + << w->name() << " already exists in valueStack" + << endl; + delete w; w = 0; + } + } + } +} + +KMSearchRule::Function KMail::RuleWidgetHandlerManager::function( const QCString& field, + const QWidgetStack *functionStack ) const +{ + for ( const_iterator it = mHandlers.begin(); it != mHandlers.end(); ++it ) { + const KMSearchRule::Function func = (*it)->function( field, + functionStack ); + if ( func != KMSearchRule::FuncNone ) + return func; + } + return KMSearchRule::FuncNone; +} + +QString KMail::RuleWidgetHandlerManager::value( const QCString& field, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const +{ + for ( const_iterator it = mHandlers.begin(); it != mHandlers.end(); ++it ) { + const QString val = (*it)->value( field, functionStack, valueStack ); + if ( !val.isEmpty() ) + return val; + } + return QString::null; +} + +QString KMail::RuleWidgetHandlerManager::prettyValue( const QCString& field, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const +{ + for ( const_iterator it = mHandlers.begin(); it != mHandlers.end(); ++it ) { + const QString val = (*it)->prettyValue( field, functionStack, valueStack ); + if ( !val.isEmpty() ) + return val; + } + return QString::null; +} + +void KMail::RuleWidgetHandlerManager::reset( QWidgetStack *functionStack, + QWidgetStack *valueStack ) const +{ + for ( const_iterator it = mHandlers.begin(); it != mHandlers.end(); ++it ) { + (*it)->reset( functionStack, valueStack ); + } + update( "", functionStack, valueStack ); +} + +void KMail::RuleWidgetHandlerManager::setRule( QWidgetStack *functionStack, + QWidgetStack *valueStack, + const KMSearchRule *rule ) const +{ + assert( rule ); + reset( functionStack, valueStack ); + for ( const_iterator it = mHandlers.begin(); it != mHandlers.end(); ++it ) { + if ( (*it)->setRule( functionStack, valueStack, rule ) ) + return; + } +} + +void KMail::RuleWidgetHandlerManager::update( const QCString &field, + QWidgetStack *functionStack, + QWidgetStack *valueStack ) const +{ + //kdDebug(5006) << "RuleWidgetHandlerManager::update( \"" << field + // << "\", ... )" << endl; + for ( const_iterator it = mHandlers.begin(); it != mHandlers.end(); ++it ) { + if ( (*it)->update( field, functionStack, valueStack ) ) + return; + } +} + +//----------------------------------------------------------------------------- + +namespace { + // FIXME (Qt >= 4.0): + // This is a simplified and constified copy of QObject::child(). According + // to a comment in qobject.h QObject::child() will be made const in Qt 4.0. + // So once we require Qt 4.0 this can be removed. + QObject* QObject_child_const( const QObject *parent, + const char *objName ) + { + const QObjectList *list = parent->children(); + if ( !list ) + return 0; + + QObjectListIterator it( *list ); + QObject *obj; + while ( ( obj = it.current() ) ) { + ++it; + if ( !objName || qstrcmp( objName, obj->name() ) == 0 ) + break; + } + return obj; + } +} + +//----------------------------------------------------------------------------- + +// these includes are temporary and should not be needed for the code +// above this line, so they appear only here: +#include "kmaddrbook.h" +#include "kmsearchpattern.h" +#include "regexplineedit.h" +using KMail::RegExpLineEdit; + +#include +#include + +#include +#include + +//============================================================================= +// +// class TextRuleWidgetHandler +// +//============================================================================= + +namespace { + // also see KMSearchRule::matches() and KMSearchRule::Function + // if you change the following strings! + static const struct { + const KMSearchRule::Function id; + const char *displayName; + } TextFunctions[] = { + { KMSearchRule::FuncContains, I18N_NOOP( "contains" ) }, + { KMSearchRule::FuncContainsNot, I18N_NOOP( "does not contain" ) }, + { KMSearchRule::FuncEquals, I18N_NOOP( "equals" ) }, + { KMSearchRule::FuncNotEqual, I18N_NOOP( "does not equal" ) }, + { KMSearchRule::FuncRegExp, I18N_NOOP( "matches regular expr." ) }, + { KMSearchRule::FuncNotRegExp, I18N_NOOP( "does not match reg. expr." ) }, + { KMSearchRule::FuncIsInAddressbook, I18N_NOOP( "is in address book" ) }, + { KMSearchRule::FuncIsNotInAddressbook, I18N_NOOP( "is not in address book" ) }, + { KMSearchRule::FuncIsInCategory, I18N_NOOP( "is in category" ) }, + { KMSearchRule::FuncIsNotInCategory, I18N_NOOP( "is not in category" ) } + }; + static const int TextFunctionCount = + sizeof( TextFunctions ) / sizeof( *TextFunctions ); + + //--------------------------------------------------------------------------- + + QWidget * TextRuleWidgetHandler::createFunctionWidget( int number, + QWidgetStack *functionStack, + const QObject *receiver ) const + { + if ( number != 0 ) + return 0; + + QComboBox *funcCombo = new QComboBox( functionStack, "textRuleFuncCombo" ); + for ( int i = 0; i < TextFunctionCount; ++i ) { + funcCombo->insertItem( i18n( TextFunctions[i].displayName ) ); + } + funcCombo->adjustSize(); + QObject::connect( funcCombo, SIGNAL( activated( int ) ), + receiver, SLOT( slotFunctionChanged() ) ); + return funcCombo; + } + + //--------------------------------------------------------------------------- + + QWidget * TextRuleWidgetHandler::createValueWidget( int number, + QWidgetStack *valueStack, + const QObject *receiver ) const + { + if ( number == 0 ) { + RegExpLineEdit *lineEdit = + new RegExpLineEdit( valueStack, "regExpLineEdit" ); + QObject::connect( lineEdit, SIGNAL( textChanged( const QString & ) ), + receiver, SLOT( slotValueChanged() ) ); + return lineEdit; + } + + // blank QLabel to hide value widget for in-address-book rule + if ( number == 1 ) { + return new QLabel( valueStack, "textRuleValueHider" ); + } + + if ( number == 2 ) { + QComboBox *combo = new QComboBox( valueStack, "categoryCombo" ); + QStringList categories = KabcBridge::categories(); + combo->insertStringList( categories ); + QObject::connect( combo, SIGNAL( activated( int ) ), + receiver, SLOT( slotValueChanged() ) ); + return combo; + } + + return 0; + } + + //--------------------------------------------------------------------------- + + KMSearchRule::Function TextRuleWidgetHandler::currentFunction( const QWidgetStack *functionStack ) const + { + const QComboBox *funcCombo = + dynamic_cast( QObject_child_const( functionStack, + "textRuleFuncCombo" ) ); + // FIXME (Qt >= 4.0): Use the following when QObject::child() is const. + // dynamic_cast( functionStack->child( "textRuleFuncCombo", + // 0, false ) ); + if ( funcCombo ) { + return TextFunctions[funcCombo->currentItem()].id; + } + else + kdDebug(5006) << "TextRuleWidgetHandler::currentFunction: " + "textRuleFuncCombo not found." << endl; + return KMSearchRule::FuncNone; + } + + //--------------------------------------------------------------------------- + + KMSearchRule::Function TextRuleWidgetHandler::function( const QCString &, + const QWidgetStack *functionStack ) const + { + return currentFunction( functionStack ); + } + + //--------------------------------------------------------------------------- + + QString TextRuleWidgetHandler::currentValue( const QWidgetStack *valueStack, + KMSearchRule::Function func ) const + { + // here we gotta check the combobox which contains the categories + if ( func == KMSearchRule::FuncIsInCategory || + func == KMSearchRule::FuncIsNotInCategory ) { + const QComboBox *combo= + dynamic_cast( QObject_child_const( valueStack, + "categoryCombo" ) ); + // FIXME (Qt >= 4.0): Use the following when QObject::child() is const. + // dynamic_cast( valueStack->child( "categoryCombo", + // 0, false ) ); + if ( combo ) { + return combo->currentText(); + } + else { + kdDebug(5006) << "TextRuleWidgetHandler::currentValue: " + "categoryCombo not found." << endl; + return QString::null; + } + } + + //in other cases of func it is a lineedit + const RegExpLineEdit *lineEdit = + dynamic_cast( QObject_child_const( valueStack, + "regExpLineEdit" ) ); + // FIXME (Qt >= 4.0): Use the following when QObject::child() is const. + // dynamic_cast( valueStack->child( "regExpLineEdit", + // 0, false ) ); + if ( lineEdit ) { + return lineEdit->text(); + } + else + kdDebug(5006) << "TextRuleWidgetHandler::currentValue: " + "regExpLineEdit not found." << endl; + + // or anything else, like addressbook + return QString::null; + } + + //--------------------------------------------------------------------------- + + QString TextRuleWidgetHandler::value( const QCString &, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const + { + KMSearchRule::Function func = currentFunction( functionStack ); + if ( func == KMSearchRule::FuncIsInAddressbook ) + return "is in address book"; // just a non-empty dummy value + else if ( func == KMSearchRule::FuncIsNotInAddressbook ) + return "is not in address book"; // just a non-empty dummy value + else + return currentValue( valueStack, func ); + } + + //--------------------------------------------------------------------------- + + QString TextRuleWidgetHandler::prettyValue( const QCString &, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const + { + KMSearchRule::Function func = currentFunction( functionStack ); + if ( func == KMSearchRule::FuncIsInAddressbook ) + return i18n( "is in address book" ); + else if ( func == KMSearchRule::FuncIsNotInAddressbook ) + return i18n( "is not in address book" ); + else + return currentValue( valueStack, func ); + } + + //--------------------------------------------------------------------------- + + bool TextRuleWidgetHandler::handlesField( const QCString & ) const + { + return true; // we handle all fields (as fallback) + } + + //--------------------------------------------------------------------------- + + void TextRuleWidgetHandler::reset( QWidgetStack *functionStack, + QWidgetStack *valueStack ) const + { + // reset the function combo box + QComboBox *funcCombo = + dynamic_cast( functionStack->child( "textRuleFuncCombo", + 0, false ) ); + if ( funcCombo ) { + funcCombo->blockSignals( true ); + funcCombo->setCurrentItem( 0 ); + funcCombo->blockSignals( false ); + } + + // reset the value widget + RegExpLineEdit *lineEdit = + dynamic_cast( valueStack->child( "regExpLineEdit", + 0, false ) ); + if ( lineEdit ) { + lineEdit->blockSignals( true ); + lineEdit->clear(); + lineEdit->blockSignals( false ); + lineEdit->showEditButton( false ); + valueStack->raiseWidget( lineEdit ); + } + + QComboBox *combo = + dynamic_cast( valueStack->child( "categoryCombo", + 0, false ) ); + if (combo) { + combo->blockSignals( true ); + combo->setCurrentItem( 0 ); + combo->blockSignals( false ); + } + } + + //--------------------------------------------------------------------------- + + bool TextRuleWidgetHandler::setRule( QWidgetStack *functionStack, + QWidgetStack *valueStack, + const KMSearchRule *rule ) const + { + if ( !rule ) { + reset( functionStack, valueStack ); + return false; + } + + const KMSearchRule::Function func = rule->function(); + int i = 0; + for ( ; i < TextFunctionCount; ++i ) + if ( func == TextFunctions[i].id ) + break; + QComboBox *funcCombo = + dynamic_cast( functionStack->child( "textRuleFuncCombo", + 0, false ) ); + if ( funcCombo ) { + funcCombo->blockSignals( true ); + if ( i < TextFunctionCount ) + funcCombo->setCurrentItem( i ); + else { + kdDebug(5006) << "TextRuleWidgetHandler::setRule( " + << rule->asString() + << " ): unhandled function" << endl; + funcCombo->setCurrentItem( 0 ); + } + funcCombo->blockSignals( false ); + functionStack->raiseWidget( funcCombo ); + } + + if ( func == KMSearchRule::FuncIsInAddressbook || + func == KMSearchRule::FuncIsNotInAddressbook ) { + QWidget *w = + static_cast( valueStack->child( "textRuleValueHider", + 0, false ) ); + valueStack->raiseWidget( w ); + } + else if ( func == KMSearchRule::FuncIsInCategory || + func == KMSearchRule::FuncIsNotInCategory) { + QComboBox *combo = + static_cast( valueStack->child( "categoryCombo", + 0, false ) ); + combo->blockSignals( true ); + for ( i = 0; i < combo->count(); ++i ) + if ( rule->contents() == combo->text( i ) ) { + combo->setCurrentItem( i ); + break; + } + if ( i == combo->count() ) + combo->setCurrentItem( 0 ); + + combo->blockSignals( false ); + valueStack->raiseWidget( combo ); + } + else { + RegExpLineEdit *lineEdit = + dynamic_cast( valueStack->child( "regExpLineEdit", + 0, false ) ); + if ( lineEdit ) { + lineEdit->blockSignals( true ); + lineEdit->setText( rule->contents() ); + lineEdit->blockSignals( false ); + lineEdit->showEditButton( func == KMSearchRule::FuncRegExp || + func == KMSearchRule::FuncNotRegExp ); + valueStack->raiseWidget( lineEdit ); + } + } + return true; + } + + + //--------------------------------------------------------------------------- + + bool TextRuleWidgetHandler::update( const QCString &, + QWidgetStack *functionStack, + QWidgetStack *valueStack ) const + { + // raise the correct function widget + functionStack->raiseWidget( + static_cast( functionStack->child( "textRuleFuncCombo", + 0, false ) ) ); + + // raise the correct value widget + KMSearchRule::Function func = currentFunction( functionStack ); + if ( func == KMSearchRule::FuncIsInAddressbook || + func == KMSearchRule::FuncIsNotInAddressbook ) { + valueStack->raiseWidget( + static_cast( valueStack->child( "textRuleValueHider", + 0, false ) ) ); + } + else if ( func == KMSearchRule::FuncIsInCategory || + func == KMSearchRule::FuncIsNotInCategory) { + valueStack->raiseWidget( + static_cast( valueStack->child( "categoryCombo", + 0, false ) ) ); + } + else { + RegExpLineEdit *lineEdit = + dynamic_cast( valueStack->child( "regExpLineEdit", + 0, false ) ); + if ( lineEdit ) { + lineEdit->showEditButton( func == KMSearchRule::FuncRegExp || + func == KMSearchRule::FuncNotRegExp ); + valueStack->raiseWidget( lineEdit ); + } + } + return true; + } + +} // anonymous namespace for TextRuleWidgetHandler + + +//============================================================================= +// +// class MessageRuleWidgetHandler +// +//============================================================================= + +namespace { + // also see KMSearchRule::matches() and KMSearchRule::Function + // if you change the following strings! + static const struct { + const KMSearchRule::Function id; + const char *displayName; + } MessageFunctions[] = { + { KMSearchRule::FuncContains, I18N_NOOP( "contains" ) }, + { KMSearchRule::FuncContainsNot, I18N_NOOP( "does not contain" ) }, + { KMSearchRule::FuncRegExp, I18N_NOOP( "matches regular expr." ) }, + { KMSearchRule::FuncNotRegExp, I18N_NOOP( "does not match reg. expr." ) }, + { KMSearchRule::FuncHasAttachment, I18N_NOOP( "has an attachment" ) }, + { KMSearchRule::FuncHasNoAttachment, I18N_NOOP( "has no attachment" ) }, + }; + static const int MessageFunctionCount = + sizeof( MessageFunctions ) / sizeof( *MessageFunctions ); + + //--------------------------------------------------------------------------- + + QWidget * MessageRuleWidgetHandler::createFunctionWidget( int number, + QWidgetStack *functionStack, + const QObject *receiver ) const + { + if ( number != 0 ) + return 0; + + QComboBox *funcCombo = new QComboBox( functionStack, "messageRuleFuncCombo" ); + for ( int i = 0; i < MessageFunctionCount; ++i ) { + funcCombo->insertItem( i18n( MessageFunctions[i].displayName ) ); + } + funcCombo->adjustSize(); + QObject::connect( funcCombo, SIGNAL( activated( int ) ), + receiver, SLOT( slotFunctionChanged() ) ); + return funcCombo; + } + + //--------------------------------------------------------------------------- + + QWidget * MessageRuleWidgetHandler::createValueWidget( int number, + QWidgetStack *valueStack, + const QObject *receiver ) const + { + if ( number == 0 ) { + RegExpLineEdit *lineEdit = + new RegExpLineEdit( valueStack, "regExpLineEdit" ); + QObject::connect( lineEdit, SIGNAL( textChanged( const QString & ) ), + receiver, SLOT( slotValueChanged() ) ); + return lineEdit; + } + + // blank QLabel to hide value widget for has-attachment rule + if ( number == 1 ) { + return new QLabel( valueStack, "textRuleValueHider" ); + } + + return 0; + } + + //--------------------------------------------------------------------------- + + KMSearchRule::Function MessageRuleWidgetHandler::currentFunction( const QWidgetStack *functionStack ) const + { + const QComboBox *funcCombo = + dynamic_cast( QObject_child_const( functionStack, + "messageRuleFuncCombo" ) ); + // FIXME (Qt >= 4.0): Use the following when QObject::child() is const. + // dynamic_cast( functionStack->child( "messageRuleFuncCombo", + // 0, false ) ); + if ( funcCombo ) { + return MessageFunctions[funcCombo->currentItem()].id; + } + else + kdDebug(5006) << "MessageRuleWidgetHandler::currentFunction: " + "messageRuleFuncCombo not found." << endl; + return KMSearchRule::FuncNone; + } + + //--------------------------------------------------------------------------- + + KMSearchRule::Function MessageRuleWidgetHandler::function( const QCString & field, + const QWidgetStack *functionStack ) const + { + if ( !handlesField( field ) ) + return KMSearchRule::FuncNone; + + return currentFunction( functionStack ); + } + + //--------------------------------------------------------------------------- + + QString MessageRuleWidgetHandler::currentValue( const QWidgetStack *valueStack, + KMSearchRule::Function ) const + { + const RegExpLineEdit *lineEdit = + dynamic_cast( QObject_child_const( valueStack, + "regExpLineEdit" ) ); + // FIXME (Qt >= 4.0): Use the following when QObject::child() is const. + // dynamic_cast( valueStack->child( "regExpLineEdit", + // 0, false ) ); + if ( lineEdit ) { + return lineEdit->text(); + } + else + kdDebug(5006) << "MessageRuleWidgetHandler::currentValue: " + "regExpLineEdit not found." << endl; + + return QString::null; + } + + //--------------------------------------------------------------------------- + + QString MessageRuleWidgetHandler::value( const QCString & field, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const + { + if ( !handlesField( field ) ) + return QString::null; + + KMSearchRule::Function func = currentFunction( functionStack ); + if ( func == KMSearchRule::FuncHasAttachment ) + return "has an attachment"; // just a non-empty dummy value + else if ( func == KMSearchRule::FuncHasNoAttachment ) + return "has no attachment"; // just a non-empty dummy value + else + return currentValue( valueStack, func ); + } + + //--------------------------------------------------------------------------- + + QString MessageRuleWidgetHandler::prettyValue( const QCString & field, + const QWidgetStack *functionStack, + const QWidgetStack *valueStack ) const + { + if ( !handlesField( field ) ) + return QString::null; + + KMSearchRule::Function func = currentFunction( functionStack ); + if ( func == KMSearchRule::FuncHasAttachment ) + return i18n( "has an attachment" ); + else if ( func == KMSearchRule::FuncHasNoAttachment ) + return i18n( "has no attachment" ); + else + return currentValue( valueStack, func ); + } + + //--------------------------------------------------------------------------- + + bool MessageRuleWidgetHandler::handlesField( const QCString & field ) const + { + return ( field == "" ); + } + + //--------------------------------------------------------------------------- + + void MessageRuleWidgetHandler::reset( QWidgetStack *functionStack, + QWidgetStack *valueStack ) const + { + // reset the function combo box + QComboBox *funcCombo = + dynamic_cast( functionStack->child( "messageRuleFuncCombo", + 0, false ) ); + if ( funcCombo ) { + funcCombo->blockSignals( true ); + funcCombo->setCurrentItem( 0 ); + funcCombo->blockSignals( false ); + } + + // reset the value widget + RegExpLineEdit *lineEdit = + dynamic_cast( valueStack->child( "regExpLineEdit", + 0, false ) ); + if ( lineEdit ) { + lineEdit->blockSignals( true ); + lineEdit->clear(); + lineEdit->blockSignals( false ); + lineEdit->showEditButton( false ); + valueStack->raiseWidget( lineEdit ); + } + } + + //--------------------------------------------------------------------------- + + bool MessageRuleWidgetHandler::setRule( QWidgetStack *functionStack, + QWidgetStack *valueStack, + const KMSearchRule *rule ) const + { + if ( !rule || !handlesField( rule->field() ) ) { + reset( functionStack, valueStack ); + return false; + } + + const KMSearchRule::Function func = rule->function(); + int i = 0; + for ( ; i < MessageFunctionCount; ++i ) + if ( func == MessageFunctions[i].id ) + break; + QComboBox *funcCombo = + dynamic_cast( functionStack->child( "messageRuleFuncCombo", + 0, false ) ); + if ( funcCombo ) { + funcCombo->blockSignals( true ); + if ( i < MessageFunctionCount ) + funcCombo->setCurrentItem( i ); + else { + kdDebug(5006) << "MessageRuleWidgetHandler::setRule( " + << rule->asString() + << " ): unhandled function" << endl; + funcCombo->setCurrentItem( 0 ); + } + funcCombo->blockSignals( false ); + functionStack->raiseWidget( funcCombo ); + } + + if ( func == KMSearchRule::FuncHasAttachment || + func == KMSearchRule::FuncHasNoAttachment ) { + QWidget *w = + static_cast( valueStack->child( "textRuleValueHider", + 0, false ) ); + valueStack->raiseWidget( w ); + } + else { + RegExpLineEdit *lineEdit = + dynamic_cast( valueStack->child( "regExpLineEdit", + 0, false ) ); + if ( lineEdit ) { + lineEdit->blockSignals( true ); + lineEdit->setText( rule->contents() ); + lineEdit->blockSignals( false ); + lineEdit->showEditButton( func == KMSearchRule::FuncRegExp || + func == KMSearchRule::FuncNotRegExp ); + valueStack->raiseWidget( lineEdit ); + } + } + return true; + } + + + //--------------------------------------------------------------------------- + + bool MessageRuleWidgetHandler::update( const QCString & field, + QWidgetStack *functionStack, + QWidgetStack *valueStack ) const + { + if ( !handlesField( field ) ) + return false; + // raise the correct function widget + functionStack->raiseWidget( + static_cast( functionStack->child( "messageRuleFuncCombo", + 0, false ) ) ); + + // raise the correct value widget + KMSearchRule::Function func = currentFunction( functionStack ); + if ( func == KMSearchRule::FuncHasAttachment || + func == KMSearchRule::FuncHasNoAttachment ) { + QWidget *w = + static_cast( valueStack->child( "textRuleValueHider", + 0, false ) ); + valueStack->raiseWidget( w ); + } + else { + RegExpLineEdit *lineEdit = + dynamic_cast( valueStack->child( "regExpLineEdit", + 0, false ) ); + if ( lineEdit ) { + lineEdit->showEditButton( func == KMSearchRule::FuncRegExp || + func == KMSearchRule::FuncNotRegExp ); + valueStack->raiseWidget( lineEdit ); + } + } + return true; + } + +} // anonymous namespace for MessageRuleWidgetHandler + + +//============================================================================= +// +// class StatusRuleWidgetHandler +// +//============================================================================= + +namespace { + static const struct { + const KMSearchRule::Function id; + const char *displayName; + } StatusFunctions[] = { + { KMSearchRule::FuncContains, I18N_NOOP( "is" ) }, + { KMSearchRule::FuncContainsNot, I18N_NOOP( "is not" ) } + }; + static const int StatusFunctionCount = + sizeof( StatusFunctions ) / sizeof( *StatusFunctions ); + + //--------------------------------------------------------------------------- + + QWidget * StatusRuleWidgetHandler::createFunctionWidget( int number, + QWidgetStack *functionStack, + const QObject *receiver ) const + { + if ( number != 0 ) + return 0; + + QComboBox *funcCombo = new QComboBox( functionStack, + "statusRuleFuncCombo" ); + for ( int i = 0; i < StatusFunctionCount; ++i ) { + funcCombo->insertItem( i18n( StatusFunctions[i].displayName ) ); + } + funcCombo->adjustSize(); + QObject::connect( funcCombo, SIGNAL( activated( int ) ), + receiver, SLOT( slotFunctionChanged() ) ); + return funcCombo; + } + + //--------------------------------------------------------------------------- + + QWidget * StatusRuleWidgetHandler::createValueWidget( int number, + QWidgetStack *valueStack, + const QObject *receiver ) const + { + if ( number != 0 ) + return 0; + + QComboBox *statusCombo = new QComboBox( valueStack, + "statusRuleValueCombo" ); + for ( int i = 0; i < KMail::StatusValueCountWithoutHidden; ++i ) { + statusCombo->insertItem( UserIcon( KMail::StatusValues[ i ].icon ), i18n( KMail::StatusValues[ i ].text ) ); + } + statusCombo->adjustSize(); + QObject::connect( statusCombo, SIGNAL( activated( int ) ), + receiver, SLOT( slotValueChanged() ) ); + return statusCombo; + } + + //--------------------------------------------------------------------------- + + KMSearchRule::Function StatusRuleWidgetHandler::currentFunction( const QWidgetStack *functionStack ) const + { + const QComboBox *funcCombo = + dynamic_cast( QObject_child_const( functionStack, + "statusRuleFuncCombo" ) ); + // FIXME (Qt >= 4.0): Use the following when QObject::child() is const. + // dynamic_cast( functionStack->child( "statusRuleFuncCombo", + // 0, false ) ); + if ( funcCombo ) { + return StatusFunctions[funcCombo->currentItem()].id; + } + else + kdDebug(5006) << "StatusRuleWidgetHandler::currentFunction: " + "statusRuleFuncCombo not found." << endl; + return KMSearchRule::FuncNone; + } + + //--------------------------------------------------------------------------- + + KMSearchRule::Function StatusRuleWidgetHandler::function( const QCString & field, + const QWidgetStack *functionStack ) const + { + if ( !handlesField( field ) ) + return KMSearchRule::FuncNone; + + return currentFunction( functionStack ); + } + + //--------------------------------------------------------------------------- + + int StatusRuleWidgetHandler::currentStatusValue( const QWidgetStack *valueStack ) const + { + const QComboBox *statusCombo = + dynamic_cast( QObject_child_const( valueStack, + "statusRuleValueCombo" ) ); + // FIXME (Qt >= 4.0): Use the following when QObject::child() is const. + // dynamic_cast( valueStack->child( "statusRuleValueCombo", + // 0, false ) ); + if ( statusCombo ) { + return statusCombo->currentItem(); + } + else + kdDebug(5006) << "StatusRuleWidgetHandler::currentStatusValue: " + "statusRuleValueCombo not found." << endl; + return -1; + } + + //--------------------------------------------------------------------------- + + QString StatusRuleWidgetHandler::value( const QCString & field, + const QWidgetStack *, + const QWidgetStack *valueStack ) const + { + if ( !handlesField( field ) ) + return QString::null; + + const int status = currentStatusValue( valueStack ); + if ( status != -1 ) + return QString::fromLatin1( KMail::StatusValues[ status ].text ); + else + return QString::null; + } + + //--------------------------------------------------------------------------- + + QString StatusRuleWidgetHandler::prettyValue( const QCString & field, + const QWidgetStack *, + const QWidgetStack *valueStack ) const + { + if ( !handlesField( field ) ) + return QString::null; + + const int status = currentStatusValue( valueStack ); + if ( status != -1 ) + return i18n( KMail::StatusValues[ status ].text ); + else + return QString::null; + } + + //--------------------------------------------------------------------------- + + bool StatusRuleWidgetHandler::handlesField( const QCString & field ) const + { + return ( field == "" ); + } + + //--------------------------------------------------------------------------- + + void StatusRuleWidgetHandler::reset( QWidgetStack *functionStack, + QWidgetStack *valueStack ) const + { + // reset the function combo box + QComboBox *funcCombo = + dynamic_cast( functionStack->child( "statusRuleFuncCombo", + 0, false ) ); + if ( funcCombo ) { + funcCombo->blockSignals( true ); + funcCombo->setCurrentItem( 0 ); + funcCombo->blockSignals( false ); + } + + // reset the status value combo box + QComboBox *statusCombo = + dynamic_cast( valueStack->child( "statusRuleValueCombo", + 0, false ) ); + if ( statusCombo ) { + statusCombo->blockSignals( true ); + statusCombo->setCurrentItem( 0 ); + statusCombo->blockSignals( false ); + } + } + + //--------------------------------------------------------------------------- + + bool StatusRuleWidgetHandler::setRule( QWidgetStack *functionStack, + QWidgetStack *valueStack, + const KMSearchRule *rule ) const + { + if ( !rule || !handlesField( rule->field() ) ) { + reset( functionStack, valueStack ); + return false; + } + + // set the function + const KMSearchRule::Function func = rule->function(); + int funcIndex = 0; + for ( ; funcIndex < StatusFunctionCount; ++funcIndex ) + if ( func == StatusFunctions[funcIndex].id ) + break; + QComboBox *funcCombo = + dynamic_cast( functionStack->child( "statusRuleFuncCombo", + 0, false ) ); + if ( funcCombo ) { + funcCombo->blockSignals( true ); + if ( funcIndex < StatusFunctionCount ) + funcCombo->setCurrentItem( funcIndex ); + else { + kdDebug(5006) << "StatusRuleWidgetHandler::setRule( " + << rule->asString() + << " ): unhandled function" << endl; + funcCombo->setCurrentItem( 0 ); + } + funcCombo->blockSignals( false ); + functionStack->raiseWidget( funcCombo ); + } + + // set the value + const QString value = rule->contents(); + int valueIndex = 0; + for ( ; valueIndex < KMail::StatusValueCountWithoutHidden; ++valueIndex ) + if ( value == QString::fromLatin1( + KMail::StatusValues[ valueIndex ].text ) ) + break; + QComboBox *statusCombo = + dynamic_cast( valueStack->child( "statusRuleValueCombo", + 0, false ) ); + if ( statusCombo ) { + statusCombo->blockSignals( true ); + if ( valueIndex < KMail::StatusValueCountWithoutHidden ) + statusCombo->setCurrentItem( valueIndex ); + else { + kdDebug(5006) << "StatusRuleWidgetHandler::setRule( " + << rule->asString() + << " ): unhandled value" << endl; + statusCombo->setCurrentItem( 0 ); + } + statusCombo->blockSignals( false ); + valueStack->raiseWidget( statusCombo ); + } + return true; + } + + + //--------------------------------------------------------------------------- + + bool StatusRuleWidgetHandler::update( const QCString &field, + QWidgetStack *functionStack, + QWidgetStack *valueStack ) const + { + if ( !handlesField( field ) ) + return false; + + // raise the correct function widget + functionStack->raiseWidget( + static_cast( functionStack->child( "statusRuleFuncCombo", + 0, false ) ) ); + + // raise the correct value widget + valueStack->raiseWidget( + static_cast( valueStack->child( "statusRuleValueCombo", + 0, false ) ) ); + return true; + } + +} // anonymous namespace for StatusRuleWidgetHandler + + +//============================================================================= +// +// class NumericRuleWidgetHandler +// +//============================================================================= + +namespace { + static const struct { + const KMSearchRule::Function id; + const char *displayName; + } NumericFunctions[] = { + { KMSearchRule::FuncEquals, I18N_NOOP( "is equal to" ) }, + { KMSearchRule::FuncNotEqual, I18N_NOOP( "is not equal to" ) }, + { KMSearchRule::FuncIsGreater, I18N_NOOP( "is greater than" ) }, + { KMSearchRule::FuncIsLessOrEqual, I18N_NOOP( "is less than or equal to" ) }, + { KMSearchRule::FuncIsLess, I18N_NOOP( "is less than" ) }, + { KMSearchRule::FuncIsGreaterOrEqual, I18N_NOOP( "is greater than or equal to" ) } + }; + static const int NumericFunctionCount = + sizeof( NumericFunctions ) / sizeof( *NumericFunctions ); + + //--------------------------------------------------------------------------- + + QWidget * NumericRuleWidgetHandler::createFunctionWidget( int number, + QWidgetStack *functionStack, + const QObject *receiver ) const + { + if ( number != 0 ) + return 0; + + QComboBox *funcCombo = new QComboBox( functionStack, + "numericRuleFuncCombo" ); + for ( int i = 0; i < NumericFunctionCount; ++i ) { + funcCombo->insertItem( i18n( NumericFunctions[i].displayName ) ); + } + funcCombo->adjustSize(); + QObject::connect( funcCombo, SIGNAL( activated( int ) ), + receiver, SLOT( slotFunctionChanged() ) ); + return funcCombo; + } + + //--------------------------------------------------------------------------- + + QWidget * NumericRuleWidgetHandler::createValueWidget( int number, + QWidgetStack *valueStack, + const QObject *receiver ) const + { + if ( number != 0 ) + return 0; + + KIntNumInput *numInput = new KIntNumInput( valueStack, "KIntNumInput" ); + QObject::connect( numInput, SIGNAL( valueChanged( int ) ), + receiver, SLOT( slotValueChanged() ) ); + return numInput; + } + + //--------------------------------------------------------------------------- + + KMSearchRule::Function NumericRuleWidgetHandler::currentFunction( const QWidgetStack *functionStack ) const + { + const QComboBox *funcCombo = + dynamic_cast( QObject_child_const( functionStack, + "numericRuleFuncCombo" ) ); + // FIXME (Qt >= 4.0): Use the following when QObject::child() is const. + // dynamic_cast( functionStack->child( "numericRuleFuncCombo", + // 0, false ) ); + if ( funcCombo ) { + return NumericFunctions[funcCombo->currentItem()].id; + } + else + kdDebug(5006) << "NumericRuleWidgetHandler::currentFunction: " + "numericRuleFuncCombo not found." << endl; + return KMSearchRule::FuncNone; + } + + //--------------------------------------------------------------------------- + + KMSearchRule::Function NumericRuleWidgetHandler::function( const QCString & field, + const QWidgetStack *functionStack ) const + { + if ( !handlesField( field ) ) + return KMSearchRule::FuncNone; + + return currentFunction( functionStack ); + } + + //--------------------------------------------------------------------------- + + QString NumericRuleWidgetHandler::currentValue( const QWidgetStack *valueStack ) const + { + const KIntNumInput *numInput = + dynamic_cast( QObject_child_const( valueStack, + "KIntNumInput" ) ); + // FIXME (Qt >= 4.0): Use the following when QObject::child() is const. + // dynamic_cast( valueStack->child( "KIntNumInput", + // 0, false ) ); + if ( numInput ) { + return QString::number( numInput->value() ); + } + else + kdDebug(5006) << "NumericRuleWidgetHandler::currentValue: " + "KIntNumInput not found." << endl; + return QString::null; + } + + //--------------------------------------------------------------------------- + + QString NumericRuleWidgetHandler::value( const QCString & field, + const QWidgetStack *, + const QWidgetStack *valueStack ) const + { + if ( !handlesField( field ) ) + return QString::null; + + return currentValue( valueStack ); + } + + //--------------------------------------------------------------------------- + + QString NumericRuleWidgetHandler::prettyValue( const QCString & field, + const QWidgetStack *, + const QWidgetStack *valueStack ) const + { + if ( !handlesField( field ) ) + return QString::null; + + return currentValue( valueStack ); + } + + //--------------------------------------------------------------------------- + + bool NumericRuleWidgetHandler::handlesField( const QCString & field ) const + { + return ( field == "" || field == "" ); + } + + //--------------------------------------------------------------------------- + + void NumericRuleWidgetHandler::reset( QWidgetStack *functionStack, + QWidgetStack *valueStack ) const + { + // reset the function combo box + QComboBox *funcCombo = + dynamic_cast( functionStack->child( "numericRuleFuncCombo", + 0, false ) ); + if ( funcCombo ) { + funcCombo->blockSignals( true ); + funcCombo->setCurrentItem( 0 ); + funcCombo->blockSignals( false ); + } + + // reset the value widget + KIntNumInput *numInput = + dynamic_cast( valueStack->child( "KIntNumInput", + 0, false ) ); + if ( numInput ) { + numInput->blockSignals( true ); + numInput->setValue( 0 ); + numInput->blockSignals( false ); + } + } + + //--------------------------------------------------------------------------- + + void initNumInput( KIntNumInput *numInput, const QCString &field ) + { + if ( field == "" ) { + numInput->setMinValue( 0 ); + numInput->setSuffix( i18n( " bytes" ) ); + } + else { + numInput->setMinValue( -10000 ); + numInput->setSuffix( i18n( " days" ) ); + } + } + + //--------------------------------------------------------------------------- + + bool NumericRuleWidgetHandler::setRule( QWidgetStack *functionStack, + QWidgetStack *valueStack, + const KMSearchRule *rule ) const + { + if ( !rule || !handlesField( rule->field() ) ) { + reset( functionStack, valueStack ); + return false; + } + + // set the function + const KMSearchRule::Function func = rule->function(); + int funcIndex = 0; + for ( ; funcIndex < NumericFunctionCount; ++funcIndex ) + if ( func == NumericFunctions[funcIndex].id ) + break; + QComboBox *funcCombo = + dynamic_cast( functionStack->child( "numericRuleFuncCombo", + 0, false ) ); + if ( funcCombo ) { + funcCombo->blockSignals( true ); + if ( funcIndex < NumericFunctionCount ) + funcCombo->setCurrentItem( funcIndex ); + else { + kdDebug(5006) << "NumericRuleWidgetHandler::setRule( " + << rule->asString() + << " ): unhandled function" << endl; + funcCombo->setCurrentItem( 0 ); + } + funcCombo->blockSignals( false ); + functionStack->raiseWidget( funcCombo ); + } + + // set the value + bool ok; + int value = rule->contents().toInt( &ok ); + if ( !ok ) + value = 0; + KIntNumInput *numInput = + dynamic_cast( valueStack->child( "KIntNumInput", + 0, false ) ); + if ( numInput ) { + initNumInput( numInput, rule->field() ); + numInput->blockSignals( true ); + numInput->setValue( value ); + numInput->blockSignals( false ); + valueStack->raiseWidget( numInput ); + } + return true; + } + + + //--------------------------------------------------------------------------- + + bool NumericRuleWidgetHandler::update( const QCString &field, + QWidgetStack *functionStack, + QWidgetStack *valueStack ) const + { + if ( !handlesField( field ) ) + return false; + + // raise the correct function widget + functionStack->raiseWidget( + static_cast( functionStack->child( "numericRuleFuncCombo", + 0, false ) ) ); + + // raise the correct value widget + KIntNumInput *numInput = + dynamic_cast( valueStack->child( "KIntNumInput", + 0, false ) ); + if ( numInput ) { + initNumInput( numInput, field ); + valueStack->raiseWidget( numInput ); + } + return true; + } + +} // anonymous namespace for NumericRuleWidgetHandler + -- cgit v1.2.1