kapi filter fixes

2 files changed, 15 insertions, 4 deletions

diff --git a/kaddressbook/filter.cpp b/kaddressbook/filter.cpp
index 7a869fa..12ab1e3 100644
--- a/kaddressbook/filter.cpp
+++ b/kaddressbook/filter.cpp
@@ -10,162 +10,171 @@
     This program 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.           
                                                                         
     As a special exception, permission is given to link this program    
     with any edition of Qt, and distribute the resulting executable,    
     without including the source code for Qt in the source distribution.
 */                                                                      
 
 #include <kconfig.h>
 #include <kconfigbase.h>
 #include <kdebug.h>
 
 #include "kabprefs.h"
 
 #include "filter.h"
 #include <secrecy.h>
 
 Filter::Filter()
-  : mName( QString::null ), mMatchRule( Matching ), mEnabled( true ),
+  : mName( QString::null ), mMatchRule( NotMatching ), mEnabled( true ),
     mInternal( false )
 {
     mCriteria = ShowPublic | ShowPrivate| ShowConfidential ;
+    noName = true;
 }
 
 Filter::Filter( const QString &name )
-  : mName( name ), mMatchRule( Matching ), mEnabled( true ),
+  : mName( name ), mMatchRule( NotMatching ), mEnabled( true ),
     mInternal( false )
 {
     mCriteria = ShowPublic | ShowPrivate| ShowConfidential ;
+    noName = false;
 }
 
 Filter::~Filter()
 {
 }
 
 void Filter::setName( const QString &name )
 {
   mName = name;
+  noName = false;
 }
 
 const QString &Filter::name() const
 {
   return mName;
 }
 
 bool Filter::isInternal() const
 {
   return mInternal;
 }
 
 void Filter::apply( KABC::Addressee::List &addresseeList )
 {
+    if ( noName )
+        return;
   KABC::Addressee::List::Iterator iter;
   for ( iter = addresseeList.begin(); iter != addresseeList.end(); ) {
     if ( filterAddressee( *iter ) )
       ++iter;
     else
     {
 #ifndef KAB_EMBEDDED
       iter = addresseeList.erase( iter );
 #else //KAB_EMBEDDED
       iter = addresseeList.remove( iter );
 #endif //KAB_EMBEDDED
     }
   }
 }
 
 bool Filter::filterAddressee( const KABC::Addressee &a )
 {
+  
+    if ( noName )
+        return true;
+    //qDebug("Filter::filterAddressee %s",mName.latin1() );
     switch ( a.secrecy().type()) {
     case KABC::Secrecy::Public: 
         if (! (mCriteria & ShowPublic ))
             return false;
         break;
     case KABC::Secrecy::Private:
         if (! (mCriteria & ShowPrivate ))
             return false;
         break;
     case KABC::Secrecy::Confidential:
         if (! (mCriteria & ShowConfidential ))
             return false;
         break;
     default:
         return false;
         break;
     }
   QStringList::Iterator iter;
   iter = mCategoryList.begin();
-  // empty filter always matches
 
   if ( iter == mCategoryList.end() )
-    return true;
+      return ( !(mMatchRule == Matching) );
 
   for ( ; iter != mCategoryList.end(); ++iter ) {
     if ( a.hasCategory( *iter ) )
       return ( mMatchRule == Matching );
   }
   
   return !( mMatchRule == Matching );
 }
 
 void Filter::setEnabled( bool on )
 {
   mEnabled = on;
 }
 
 bool Filter::isEnabled() const
 {
   return mEnabled;
 }
 
 void Filter::setCategories( const QStringList &list )
 {
   mCategoryList = list;
 }
     
 const QStringList &Filter::categories() const
 {
   return mCategoryList;
 }
 
 void Filter::save( KConfig *config )
 {
   config->writeEntry( "Name", mName );
   config->writeEntry( "Enabled", mEnabled );
   config->writeEntry( "Categories", mCategoryList );
   config->writeEntry( "MatchRule", (int)mMatchRule );
   config->writeEntry( "Criteria", (int)mCriteria );
 }
 
 void Filter::restore( KConfig *config )
 {
+    noName = false;
   mName = config->readEntry( "Name", "<internal error>" );
   mEnabled = config->readBoolEntry( "Enabled", true );
   mCategoryList = config->readListEntry( "Categories" );
   mMatchRule = (MatchRule)config->readNumEntry( "MatchRule", Matching );
   mCriteria = config->readNumEntry( "Criteria", (ShowPublic | ShowPrivate| ShowConfidential ) );
 }
 
 void Filter::save( KConfig *config, QString baseGroup, Filter::List &list )
 {
   {
     KConfigGroupSaver s( config, baseGroup );
 
     // remove the old filters
     uint count = config->readNumEntry( "Count" );
     /*   // memory access violation here
     for ( uint i = 0; i < count; ++i )
       config->deleteGroup( QString( "%1_%2" ).arg( baseGroup ).arg( i ) );
     */
   }
   
   int index = 0;
   Filter::List::Iterator iter;
   for ( iter = list.begin(); iter != list.end(); ++iter ) {
     if ( !(*iter).mInternal ) {
@@ -185,44 +194,45 @@ void Filter::save( KConfig *config, QString baseGroup, Filter::List &list )
 Filter::List Filter::restore( KConfig *config, QString baseGroup )
 {
   Filter::List list;
   int count = 0;
   Filter f;
   
   {
     KConfigGroupSaver s( config, baseGroup );
     count = config->readNumEntry( "Count", 0 );
   }
   
   for ( int i = 0; i < count; i++ ) {
     {
       KConfigGroupSaver s( config, QString( "%1_%2" ).arg( baseGroup ).arg( i ) );
       f.restore( config );
     }
 
     list.append( f );
   }
 
   if ( list.isEmpty()) {
       QStringList cats = KABPrefs::instance()->mCustomCategories;
       for ( QStringList::Iterator it = cats.begin(); it != cats.end(); ++it ) {
           Filter filter;
+          filter.noName = false;
           filter.mName = *it;
           filter.mEnabled = true;
           filter.mCategoryList = *it;
           filter.mMatchRule = Matching;
           filter.mInternal = true;
           list.append( filter );
       }
   }
   return list;
 }
 
 void Filter::setMatchRule( MatchRule rule )
 {
   mMatchRule = rule;
 }
     
 Filter::MatchRule Filter::matchRule() const
 {
   return mMatchRule;
 }
diff --git a/kaddressbook/filter.h b/kaddressbook/filter.h
index 93f1352..f4ae123 100644
--- a/kaddressbook/filter.h
+++ b/kaddressbook/filter.h
@@ -125,33 +125,34 @@ class Filter
     
     /**
       Restores a list of filters from a config file.
     
       @param config The config file to read from.
       @param baseGroup The base group name to be used to find the filters
       
       @return The list of filters.
      */
     static Filter::List restore( KConfig *config, QString baseGroup );
     
     /**
       Sets the filter rule. If the rule is Filter::Matching (default),
       then the filter will return true on items that match the filter.
       If the rule is Filter::NotMatching, then the filter will return
       true on items that do not match the filter.
      */
     void setMatchRule( MatchRule rule );
     
     /** @return The current match rule.
     */
     MatchRule matchRule() const;
    
   private:
+    bool noName;
     int mCriteria;
     QString mName;
     QStringList mCategoryList;
     MatchRule mMatchRule;
     bool mEnabled;
     bool mInternal;
 };
 
 #endif