filter.cpp

/*
    This file is part of KAddressBook.
    Copyright (c) 2002 Mike Pilone <mpilone@slac.com>
 
    This program 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.
 
    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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
    As a special exception, permission is given to link this program
    with any edition of TQt, and distribute the resulting executable,
    without including the source code for TQt in the source distribution.
*/
 
#include <tdeconfig.h>
#include <kdebug.h>
 
#include "kabprefs.h"
 
#include "filter.h"
 
Filter::Filter()
  : mName( TQString() ), mMatchRule( Matching ), mEnabled( true ),
    mInternal( false ), mIsEmpty( true )
{
}
 
Filter::Filter( const TQString &name )
  : mName( name ), mMatchRule( Matching ), mEnabled( true ),
    mInternal( false ), mIsEmpty( false )
{
}
 
Filter::~Filter()
{
}
 
void Filter::setName( const TQString &name )
{
  mName = name;
 
  mIsEmpty = false;
}
 
const TQString &Filter::name() const
{
  return mName;
}
 
bool Filter::isInternal() const
{
  return mInternal;
}
 
void Filter::apply( TDEABC::Addressee::List &addresseeList )
{
  TDEABC::Addressee::List::Iterator iter;
  for ( iter = addresseeList.begin(); iter != addresseeList.end(); ) {
    if ( filterAddressee( *iter ) )
      ++iter;
    else
      iter = addresseeList.erase( iter );
  }
}
 
bool Filter::filterAddressee( const TDEABC::Addressee &a ) const
{
  TQStringList::ConstIterator iter;
  iter = mCategoryList.begin();
  // empty filter always matches
 
  if ( iter == mCategoryList.end() ) {
    if ( mMatchRule == Matching )
      return true;
    else {
      if ( a.categories().empty() )
        return true;
      else
        return false;
    }
  }
 
  for ( ; iter != mCategoryList.end(); ++iter ) {
    if ( a.hasCategory( *iter ) )
      return ( mMatchRule == Matching );
  }
 
  return !( mMatchRule == Matching );
}
 
void Filter::setEnabled( bool on )
{
  mEnabled = on;
 
  mIsEmpty = false;
}
 
bool Filter::isEnabled() const
{
  return mEnabled;
}
 
void Filter::setCategories( const TQStringList &list )
{
  mCategoryList = list;
 
  mIsEmpty = false;
}
 
const TQStringList &Filter::categories() const
{
  return mCategoryList;
}
 
void Filter::save( TDEConfig *config )
{
  config->writeEntry( "Name", mName );
  config->writeEntry( "Enabled", mEnabled );
  config->writeEntry( "Categories", mCategoryList );
  config->writeEntry( "MatchRule", (int)mMatchRule );
}
 
void Filter::restore( TDEConfig *config )
{
  mName = config->readEntry( "Name", "<internal error>" );
  mEnabled = config->readBoolEntry( "Enabled", true );
  mCategoryList = config->readListEntry( "Categories" );
  mMatchRule = (MatchRule)config->readNumEntry( "MatchRule", Matching );
 
  mIsEmpty = false;
}
 
void Filter::save( TDEConfig *config, const TQString &baseGroup, Filter::List &list )
{
  {
    TDEConfigGroupSaver s( config, baseGroup );
 
    // remove the old filters
    uint count = config->readNumEntry( "Count" );
    for ( uint i = 0; i < count; ++i )
      config->deleteGroup( TQString( "%1_%2" ).arg( baseGroup ).arg( i ) );
 
  }
 
  int index = 0;
  Filter::List::Iterator iter;
  for ( iter = list.begin(); iter != list.end(); ++iter ) {
    if ( !(*iter).mInternal ) {
      TDEConfigGroupSaver s( config, TQString( "%1_%2" ).arg( baseGroup )
                                                     .arg( index ) );
      (*iter).save( config );
      index++;
    }
  }
 
  TDEConfigGroupSaver s( config, baseGroup );
  config->writeEntry( "Count", index );
}
 
Filter::List Filter::restore( TDEConfig *config, const TQString &baseGroup )
{
  Filter::List list;
  int count = 0;
  Filter f;
 
  {
    TDEConfigGroupSaver s( config, baseGroup );
    count = config->readNumEntry( "Count", 0 );
  }
 
  for ( int i = 0; i < count; i++ ) {
    {
      TDEConfigGroupSaver s( config, TQString( "%1_%2" ).arg( baseGroup ).arg( i ) );
      f.restore( config );
    }
 
    list.append( f );
  }
 
  const TQStringList cats = KABPrefs::instance()->customCategories();
  for ( TQStringList::ConstIterator it = cats.begin(); it != cats.end(); ++it ) {
    Filter filter;
    filter.mName = *it;
    filter.mEnabled = true;
    filter.mCategoryList = *it;
    filter.mMatchRule = Matching;
    filter.mInternal = true;
    filter.mIsEmpty = false;
    list.append( filter );
  }
 
  return list;
}
 
void Filter::setMatchRule( MatchRule rule )
{
  mMatchRule = rule;
 
  mIsEmpty = false;
}
 
Filter::MatchRule Filter::matchRule() const
{
  return mMatchRule;
}
 
bool Filter::isEmpty() const
{
  return mIsEmpty;
}