recipientseditor.cpp

/*
    This file is part of KMail.
 
    Copyright (c) 2004 Cornelius Schumacher <schumacher@kde.org>
 
    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 "recipientseditor.h"
 
#include "recipientspicker.h"
#include "twindowpositioner.h"
#include "distributionlistdialog.h"
#include "globalsettings.h"
 
#include <libemailfunctions/email.h>
 
#include <tdeapplication.h>
#include <tdecompletionbox.h>
#include <kdebug.h>
#include <kinputdialog.h>
#include <tdelocale.h>
#include <kiconloader.h>
#include <tdemessagebox.h>
 
#include <tqlayout.h>
#include <tqlabel.h>
#include <tqscrollview.h>
#include <tqcombobox.h>
#include <tqhbox.h>
#include <tqtimer.h>
#include <tqpushbutton.h>
#include <tqstylesheet.h>
 
Recipient::Recipient( const TQString &email, Recipient::Type type )
  : mEmail( email ), mType( type )
{
}
 
void Recipient::setType( Type type )
{
  mType = type;
}
 
Recipient::Type Recipient::type() const
{
  return mType;
}
 
void Recipient::setEmail( const TQString &email )
{
  mEmail = email;
}
 
TQString Recipient::email() const
{
  return mEmail;
}
 
bool Recipient::isEmpty() const
{
  return mEmail.isEmpty();
}
 
int Recipient::typeToId( Recipient::Type type )
{
  return static_cast<int>( type );
}
 
Recipient::Type Recipient::idToType( int id )
{
  return static_cast<Type>( id );
}
 
TQString Recipient::typeLabel() const
{
  return typeLabel( mType );
}
 
TQString Recipient::typeLabel( Recipient::Type type )
{
  switch( type ) {
    case To:
      return i18n("To");
    case Cc:
      return i18n("CC");
    case Bcc:
      return i18n("BCC");
    case Undefined:
      break;
  }
 
  return i18n("<Undefined RecipientType>");
}
 
TQStringList Recipient::allTypeLabels()
{
  TQStringList types;
  types.append( typeLabel( To ) );
  types.append( typeLabel( Cc ) );
  types.append( typeLabel( Bcc ) );
  return types;
}
 
 
RecipientComboBox::RecipientComboBox( TQWidget *parent )
  : TQComboBox( parent )
{
}
 
void RecipientComboBox::keyPressEvent( TQKeyEvent *ev )
{
  if ( ev->key() == Key_Right ) emit rightPressed();
  else TQComboBox::keyPressEvent( ev );
}
 
 
void RecipientLineEdit::keyPressEvent( TQKeyEvent *ev )
{
  if ( ev->key() == Key_Backspace  &&  text().isEmpty() ) {
    ev->accept();
    emit deleteMe();
  } else if ( ev->key() == Key_Left && cursorPosition() == 0 ) {
    emit leftPressed();
  } else if ( ev->key() == Key_Right && cursorPosition() == (int)text().length() ) {
    emit rightPressed();
  } else {
    KMLineEdit::keyPressEvent( ev );
  }
}
 
RecipientLine::RecipientLine( TQWidget *parent )
  : TQWidget( parent ), mRecipientsCount( 0 ), mModified( false )
{
  TQBoxLayout *topLayout = new TQHBoxLayout( this );
  topLayout->setSpacing( KDialog::spacingHint() );
 
  TQStringList recipientTypes = Recipient::allTypeLabels();
 
  mCombo = new RecipientComboBox( this );
  mCombo->insertStringList( recipientTypes );
  topLayout->addWidget( mCombo );
  TQToolTip::add( mCombo, i18n("Select type of recipient") );
 
  mEdit = new RecipientLineEdit( this );
  TQToolTip::add( mEdit,
                 i18n( "Set the list of email addresses to receive this message" ) );
  topLayout->addWidget( mEdit );
  connect( mEdit, TQ_SIGNAL( returnPressed() ), TQ_SLOT( slotReturnPressed() ) );
  connect( mEdit, TQ_SIGNAL( deleteMe() ), TQ_SLOT( slotPropagateDeletion() ) );
  connect( mEdit, TQ_SIGNAL( textChanged( const TQString & ) ),
    TQ_SLOT( analyzeLine( const TQString & ) ) );
  connect( mEdit, TQ_SIGNAL( focusUp() ), TQ_SLOT( slotFocusUp() ) );
  connect( mEdit, TQ_SIGNAL( focusDown() ), TQ_SLOT( slotFocusDown() ) );
  connect( mEdit, TQ_SIGNAL( rightPressed() ), TQ_SIGNAL( rightPressed() ) );
 
  connect( mEdit, TQ_SIGNAL( leftPressed() ), mCombo, TQ_SLOT( setFocus() ) );
  connect( mCombo, TQ_SIGNAL( rightPressed() ), mEdit, TQ_SLOT( setFocus() ) );
 
  connect( mCombo, TQ_SIGNAL( activated ( int ) ),
           this, TQ_SLOT( slotTypeModified() ) );
 
  mRemoveButton = new TQPushButton( this );
  mRemoveButton->setIconSet( TDEApplication::reverseLayout() ? SmallIconSet("locationbar_erase") : SmallIconSet( "clear_left" ) );
  topLayout->addWidget( mRemoveButton );
  connect( mRemoveButton, TQ_SIGNAL( clicked() ), TQ_SLOT( slotPropagateDeletion() ) );
  TQToolTip::add( mRemoveButton, i18n("Remove recipient line") );
}
 
void RecipientLine::slotFocusUp()
{
  emit upPressed( this );
}
 
void RecipientLine::slotFocusDown()
{
  emit downPressed( this );
}
 
void RecipientLine::slotTypeModified()
{
  mModified = true;
 
  emit typeModified( this );
}
 
void RecipientLine::analyzeLine( const TQString &text )
{
  TQStringList r = KPIM::splitEmailAddrList( text );
  if ( int( r.count() ) != mRecipientsCount ) {
    mRecipientsCount = r.count();
    emit countChanged();
  }
}
 
int RecipientLine::recipientsCount()
{
  return mRecipientsCount;
}
 
void RecipientLine::setRecipient( const Recipient &rec )
{
  mEdit->setText( rec.email() );
  mCombo->setCurrentItem( Recipient::typeToId( rec.type() ) );
}
 
void RecipientLine::setRecipient( const TQString &email )
{
  setRecipient( Recipient( email ) );
}
 
Recipient RecipientLine::recipient() const
{
  return Recipient( mEdit->text(),
    Recipient::idToType( mCombo->currentItem() ) );
}
 
void RecipientLine::setRecipientType( Recipient::Type type )
{
  mCombo->setCurrentItem( Recipient::typeToId( type ) );
}
 
Recipient::Type RecipientLine::recipientType() const
{
  return Recipient::idToType( mCombo->currentItem() );
}
 
void RecipientLine::activate()
{
  mEdit->setFocus();
}
 
bool RecipientLine::isActive()
{
  return mEdit->hasFocus();
}
 
bool RecipientLine::isEmpty()
{
  return mEdit->text().isEmpty();
}
 
bool RecipientLine::isModified()
{
  return mModified || mEdit->isModified();
}
 
void RecipientLine::clearModified()
{
  mModified = false;
  mEdit->clearModified();
}
 
void RecipientLine::slotReturnPressed()
{
  emit returnPressed( this );
}
 
void RecipientLine::slotPropagateDeletion()
{
  emit deleteLine( this );
}
 
void RecipientLine::keyPressEvent( TQKeyEvent *ev )
{
  if ( ev->key() == Key_Up ) {
    emit upPressed( this );
  } else if ( ev->key() == Key_Down ) {
    emit downPressed( this );
  }
}
 
int RecipientLine::setComboWidth( int w )
{
  w = TQMAX( w, mCombo->sizeHint().width() );
  mCombo->setFixedWidth( w );
  mCombo->updateGeometry();
  parentWidget()->updateGeometry();
  return w;
}
 
void RecipientLine::fixTabOrder( TQWidget *previous )
{
  setTabOrder( previous, mCombo );
  setTabOrder( mCombo, mEdit );
  setTabOrder( mEdit, mRemoveButton );
}
 
TQWidget *RecipientLine::tabOut() const
{
  return mRemoveButton;
}
 
void RecipientLine::clear()
{
  mEdit->clear();
}
 
void RecipientLine::setRemoveLineButtonEnabled( bool b )
{
  mRemoveButton->setEnabled( b );
}
 
 
// ------------ RecipientsView ---------------------
 
RecipientsView::RecipientsView( TQWidget *parent )
  : TQScrollView( parent ), mCurDelLine( 0 ),
    mLineHeight( 0 ), mFirstColumnWidth( 0 ),
    mModified( false )
{
  mCompletionMode = TDEGlobalSettings::completionMode();
  setHScrollBarMode( AlwaysOff );
  setLineWidth( 0 );
 
  addLine();
  setResizePolicy( TQScrollView::Manual );
  setSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Expanding );
 
  viewport()->setPaletteBackgroundColor( paletteBackgroundColor() );
}
 
RecipientLine *RecipientsView::activeLine()
{
  return mLines.last();
}
 
RecipientLine *RecipientsView::emptyLine()
{
  RecipientLine *line;
  for( line = mLines.first(); line; line = mLines.next() ) {
    if ( line->isEmpty() ) return line;
  }
 
  return 0;
}
 
RecipientLine *RecipientsView::addLine()
{
  RecipientLine *line = new RecipientLine( viewport() );
  addChild( line, 0, mLines.count() * mLineHeight );
  line->mEdit->setCompletionMode( mCompletionMode );
  line->show();
  connect( line, TQ_SIGNAL( returnPressed( RecipientLine * ) ),
    TQ_SLOT( slotReturnPressed( RecipientLine * ) ) );
  connect( line, TQ_SIGNAL( upPressed( RecipientLine * ) ),
    TQ_SLOT( slotUpPressed( RecipientLine * ) ) );
  connect( line, TQ_SIGNAL( downPressed( RecipientLine * ) ),
    TQ_SLOT( slotDownPressed( RecipientLine * ) ) );
  connect( line, TQ_SIGNAL( rightPressed() ), TQ_SIGNAL( focusRight() ) );
  connect( line, TQ_SIGNAL( deleteLine( RecipientLine * ) ),
    TQ_SLOT( slotDecideLineDeletion( RecipientLine * ) ) );
  connect( line, TQ_SIGNAL( countChanged() ), TQ_SLOT( calculateTotal() ) );
  connect( line, TQ_SIGNAL( typeModified( RecipientLine * ) ),
    TQ_SLOT( slotTypeModified( RecipientLine * ) ) );
  connect( line->mEdit, TQ_SIGNAL( completionModeChanged( TDEGlobalSettings::Completion ) ),
    TQ_SLOT( setCompletionMode( TDEGlobalSettings::Completion ) ) );
 
  if ( mLines.last() ) {
    if ( mLines.count() == 1 ) {
      if ( GlobalSettings::self()->secondRecipientTypeDefault() ==
         GlobalSettings::EnumSecondRecipientTypeDefault::To ) {
        line->setRecipientType( Recipient::To );
      } else {
        if ( mLines.last()->recipientType() == Recipient::Bcc ) {
          line->setRecipientType( Recipient::To );
        } else {
          line->setRecipientType( Recipient::Cc );
        }
      }
    } else {
      line->setRecipientType( mLines.last()->recipientType() );
    }
    line->fixTabOrder( mLines.last()->tabOut() );
  }
 
  mLines.append( line );
  // If there is only one line, removing it makes no sense
  if ( mLines.count() == 1 ) {
    mLines.first()->setRemoveLineButtonEnabled( false );
  } else {
    mLines.first()->setRemoveLineButtonEnabled( true );
  }
 
  mFirstColumnWidth = line->setComboWidth( mFirstColumnWidth );
 
  mLineHeight = line->minimumSizeHint().height();
 
  line->resize( viewport()->width(), mLineHeight );
 
  resizeView();
 
  calculateTotal();
 
  ensureVisible( 0, mLines.count() * mLineHeight );
 
  return line;
}
 
void RecipientsView::slotTypeModified( RecipientLine *line )
{
  if ( mLines.count() == 2 ||
       ( mLines.count() == 3 && mLines.at( 2 )->isEmpty() ) ) {
    if ( mLines.at( 1 ) == line ) {
      if ( line->recipientType() == Recipient::To ) {
        GlobalSettings::self()->setSecondRecipientTypeDefault(
          GlobalSettings::EnumSecondRecipientTypeDefault::To );
      } else if ( line->recipientType() == Recipient::Cc ) {
        GlobalSettings::self()->setSecondRecipientTypeDefault(
          GlobalSettings::EnumSecondRecipientTypeDefault::Cc );
      }
    }
  }
}
 
void RecipientsView::calculateTotal()
{
  int count = 0;
  int empty = 0;
 
  RecipientLine *line;
  for( line = mLines.first(); line; line = mLines.next() ) {
    if ( line->isEmpty() ) ++empty;
    else count += line->recipientsCount();
  }
 
  if ( empty == 0 ) addLine();
 
  emit totalChanged( count, mLines.count() );
}
 
void RecipientsView::slotReturnPressed( RecipientLine *line )
{
  if ( !line->recipient().isEmpty() ) {
    RecipientLine *empty = emptyLine();
    if ( !empty ) empty = addLine();
    activateLine( empty );
  }
}
 
void RecipientsView::slotDownPressed( RecipientLine *line )
{
  int pos = mLines.find( line );
  if ( pos >= (int)mLines.count() - 1 ) {
    emit focusDown();
  } else if ( pos >= 0 ) {
    activateLine( mLines.at( pos + 1 ) );
  }
}
 
void RecipientsView::slotUpPressed( RecipientLine *line )
{
  int pos = mLines.find( line );
  if ( pos > 0 ) {
    activateLine( mLines.at( pos - 1 ) );
  } else {
    emit focusUp();
  }
}
 
void RecipientsView::slotDecideLineDeletion( RecipientLine *line )
{
  if ( !line->isEmpty() )
    mModified = true;
  if ( mLines.count() == 1 ) {
    line->clear();
  } else {
    mCurDelLine = line;
    TQTimer::singleShot( 0, this, TQ_SLOT( slotDeleteLine( ) ) );
  }
}
 
void RecipientsView::slotDeleteLine()
{
  if ( !mCurDelLine )
    return;
 
  RecipientLine *line = mCurDelLine;
  int pos = mLines.find( line );
 
  int newPos;
  if ( pos == 0 ) newPos = pos + 1;
  else newPos = pos - 1;
 
  // if there is something left to activate, do so
  if ( mLines.at( newPos ) )
    mLines.at( newPos )->activate();
 
  mLines.remove( line );
  removeChild( line );
  delete line;
 
  bool atLeastOneToLine = false;
  unsigned int firstCC = 0;
  for( uint i = pos; i < mLines.count(); ++i ) {
    RecipientLine *line = mLines.at( i );
    moveChild( line, childX( line ), childY( line ) - mLineHeight );
    if ( line->recipientType() == Recipient::To )
      atLeastOneToLine = true;
    else if ( ( line->recipientType() == Recipient::Cc ) && ( i == 0 ) )
      firstCC = i;
  }
  // only one left, can't remove that one
  if ( mLines.count() == 1 )
    mLines.first()->setRemoveLineButtonEnabled( false );
 
  if ( !atLeastOneToLine )
    mLines.at( firstCC )->setRecipientType( Recipient::To );
 
  calculateTotal();
 
  resizeView();
}
 
void RecipientsView::resizeView()
{
  resizeContents( width(), mLines.count() * mLineHeight );
 
  if ( mLines.count() < 6 ) {
//    setFixedHeight( mLineHeight * mLines.count() );
  }
 
  parentWidget()->layout()->activate();
  emit sizeHintChanged();
  TQTimer::singleShot( 0, this, TQ_SLOT(moveCompletionPopup()) );
}
 
void RecipientsView::activateLine( RecipientLine *line )
{
  line->activate();
  ensureVisible( 0, childY( line ) );
}
 
void RecipientsView::viewportResizeEvent ( TQResizeEvent *ev )
{
  for( uint i = 0; i < mLines.count(); ++i ) {
    mLines.at( i )->resize( ev->size().width(), mLineHeight );
  }
  ensureVisible( 0, mLines.count() * mLineHeight );
}
 
TQSize RecipientsView::sizeHint() const
{
  return TQSize( 200, mLineHeight * mLines.count() );
}
 
TQSize RecipientsView::minimumSizeHint() const
{
  int height;
  uint numLines = 5;
  if ( mLines.count() < numLines ) height = mLineHeight * mLines.count();
  else height = mLineHeight * numLines;
  return TQSize( 200, height );
}
 
Recipient::List RecipientsView::recipients() const
{
  Recipient::List recipients;
 
  TQPtrListIterator<RecipientLine> it( mLines );
  RecipientLine *line;
  while( ( line = it.current() ) ) {
    if ( !line->recipient().isEmpty() ) {
      recipients.append( line->recipient() );
    }
 
    ++it;
  }
 
  return recipients;
}
 
void RecipientsView::setCompletionMode ( TDEGlobalSettings::Completion mode )
{
  if ( mCompletionMode == mode )
    return;
  mCompletionMode = mode;
 
  TQPtrListIterator<RecipientLine> it( mLines );
  RecipientLine *line;
  while( ( line = it.current() ) ) {
    line->mEdit->blockSignals( true );
    line->mEdit->setCompletionMode( mode );
    line->mEdit->blockSignals( false );
    ++it;
  }
  emit completionModeChanged( mode ); //report change to RecipientsEditor
}
 
void RecipientsView::removeRecipient( const TQString & recipient,
                                      Recipient::Type type )
{
  // search a line which matches recipient and type
  TQPtrListIterator<RecipientLine> it( mLines );
  RecipientLine *line;
  while( ( line = it.current() ) ) {
    if ( ( line->recipient().email() == recipient ) &&
         ( line->recipientType() == type ) ) {
      break;
    }
    ++it;
  }
  if ( line )
    line->slotPropagateDeletion();
}
 
bool RecipientsView::isModified()
{
  if ( mModified )
    return true;
 
  TQPtrListIterator<RecipientLine> it( mLines );
  RecipientLine *line;
  while( ( line = it.current() ) ) {
    if ( line->isModified() ) {
      return true;
    }
    ++it;
  }
 
  return false;
}
 
void RecipientsView::clearModified()
{
  mModified = false;
 
  TQPtrListIterator<RecipientLine> it( mLines );
  RecipientLine *line;
  while( ( line = it.current() ) ) {
    line->clearModified();
    ++it;
  }
}
 
void RecipientsView::setFocus()
{
  if ( mLines.last()->isActive() ) setFocusBottom();
  else setFocusTop();
}
 
void RecipientsView::setFocusTop()
{
  RecipientLine *line = mLines.first();
  if ( line ) line->activate();
  else kdWarning() << "No first" << endl;
}
 
void RecipientsView::setFocusBottom()
{
  RecipientLine *line = mLines.last();
  if ( line ) line->activate();
  else  kdWarning() << "No last" << endl;
}
 
int RecipientsView::setFirstColumnWidth( int w )
{
  mFirstColumnWidth = w;
 
  TQPtrListIterator<RecipientLine> it( mLines );
  RecipientLine *line;
  while( ( line = it.current() ) ) {
    mFirstColumnWidth = line->setComboWidth( mFirstColumnWidth );
    ++it;
  }
 
  resizeView();
  return mFirstColumnWidth;
}
 
void RecipientsView::moveCompletionPopup()
{
  for( RecipientLine* line = mLines.first(); line; line = mLines.next() ) {
    if ( line->lineEdit()->completionBox( false ) ) {
      if ( line->lineEdit()->completionBox()->isVisible() ) {
        // ### trigger moving, is there a nicer way to do that?
        line->lineEdit()->completionBox()->hide();
        line->lineEdit()->completionBox()->show();
      }
    }
  }
 
}
 
RecipientsToolTip::RecipientsToolTip( RecipientsView *view, TQWidget *parent )
  : TQToolTip( parent ), mView( view )
{
}
 
TQString RecipientsToolTip::line( const Recipient &r )
{
  TQString txt = r.email();
 
  return "&nbsp;&nbsp;" + TQStyleSheet::escape( txt ) + "<br/>";
}
 
void RecipientsToolTip::maybeTip( const TQPoint & p )
{
  TQString text = "<qt>";
 
  TQString to;
  TQString cc;
  TQString bcc;
 
  Recipient::List recipients = mView->recipients();
  Recipient::List::ConstIterator it;
  for( it = recipients.begin(); it != recipients.end(); ++it ) {
    switch( (*it).type() ) {
      case Recipient::To:
        to += line( *it );
        break;
      case Recipient::Cc:
        cc += line( *it );
        break;
      case Recipient::Bcc:
        bcc += line( *it );
        break;
      default:
        break;
    }
  }
 
  text += i18n("<b>To:</b><br/>") + to;
  if ( !cc.isEmpty() ) text += i18n("<b>CC:</b><br/>") + cc;
  if ( !bcc.isEmpty() ) text += i18n("<b>BCC:</b><br/>") + bcc;
 
  text.append( "</qt>" );
 
  TQRect geometry( p + TQPoint( 2, 2 ), TQPoint( 400, 100 ) );
 
  tip( TQRect( p.x() - 20, p.y() - 20, 40, 40 ), text, geometry );
}
 
 
SideWidget::SideWidget( RecipientsView *view, TQWidget *parent )
  : TQWidget( parent ), mView( view ), mRecipientPicker( 0 )
{
  TQBoxLayout *topLayout = new TQVBoxLayout( this );
 
  topLayout->setSpacing( KDialog::spacingHint() );
  topLayout->addStretch( 1 );
 
  mTotalLabel = new TQLabel( this );
  mTotalLabel->setAlignment( AlignCenter );
  topLayout->addWidget( mTotalLabel );
  mTotalLabel->hide();
 
  topLayout->addStretch( 1 );
 
  new RecipientsToolTip( view, mTotalLabel );
 
  mDistributionListButton = new TQPushButton( i18n("Save List..."), this );
  topLayout->addWidget( mDistributionListButton );
  mDistributionListButton->hide();
  connect( mDistributionListButton, TQ_SIGNAL( clicked() ),
    TQ_SIGNAL( saveDistributionList() ) );
  TQToolTip::add( mDistributionListButton,
    i18n("Save recipients as distribution list") );
 
  mSelectButton = new TQPushButton( i18n("Se&lect..."), this );
  topLayout->addWidget( mSelectButton );
  connect( mSelectButton, TQ_SIGNAL( clicked() ), TQ_SLOT( pickRecipient() ) );
  TQToolTip::add( mSelectButton, i18n("Select recipients from address book") );
}
 
SideWidget::~SideWidget()
{
}
 
RecipientsPicker* SideWidget::picker() const
{
  if ( !mRecipientPicker ) {
    // hacks to allow picker() to be const in the presence of lazy loading
    SideWidget *non_const_this = const_cast<SideWidget*>( this );
    mRecipientPicker = new RecipientsPicker( non_const_this );
    connect( mRecipientPicker, TQ_SIGNAL( pickedRecipient( const Recipient & ) ),
             non_const_this, TQ_SIGNAL( pickedRecipient( const Recipient & ) ) );
    mPickerPositioner = new KWindowPositioner( non_const_this, mRecipientPicker );
  }
  return mRecipientPicker;
}
 
void SideWidget::setFocus()
{
  mSelectButton->setFocus();
}
 
void SideWidget::setTotal( int recipients, int lines )
{
#if 0
  kdDebug() << "SideWidget::setTotal() recipients: " << recipients <<
    "  lines: " << lines << endl;
#endif
 
  TQString labelText;
  if ( recipients == 0 ) labelText = i18n("No recipients");
  else labelText = i18n("1 recipient","%n recipients", recipients );
  mTotalLabel->setText( labelText );
 
  if ( lines > 3 ) mTotalLabel->show();
  else mTotalLabel->hide();
 
  if ( lines > 2 ) mDistributionListButton->show();
  else mDistributionListButton->hide();
}
 
void SideWidget::pickRecipient()
{
#if 0
  TQString rec = KInputDialog::getText( "Pick Recipient",
    "Email address of recipient" );
  if ( !rec.isEmpty() ) emit pickedRecipient( rec );
#else
  RecipientsPicker *p = picker();
  p->setDefaultType( mView->activeLine()->recipientType() );
  p->setRecipients( mView->recipients() );
  p->show();
  mPickerPositioner->reposition();
  p->raise();
#endif
}
 
 
RecipientsEditor::RecipientsEditor( TQWidget *parent )
  : TQWidget( parent ), mModified( false )
{
  TQBoxLayout *topLayout = new TQHBoxLayout( this );
  topLayout->setSpacing( KDialog::spacingHint() );
 
  mRecipientsView = new RecipientsView( this );
  topLayout->addWidget( mRecipientsView );
  connect( mRecipientsView, TQ_SIGNAL( focusUp() ), TQ_SIGNAL( focusUp() ) );
  connect( mRecipientsView, TQ_SIGNAL( focusDown() ), TQ_SIGNAL( focusDown() ) );
  connect( mRecipientsView, TQ_SIGNAL( completionModeChanged( TDEGlobalSettings::Completion ) ),
    TQ_SIGNAL( completionModeChanged( TDEGlobalSettings::Completion ) ) );
 
  mSideWidget = new SideWidget( mRecipientsView, this );
  topLayout->addWidget( mSideWidget );
  connect( mSideWidget, TQ_SIGNAL( pickedRecipient( const Recipient & ) ),
    TQ_SLOT( slotPickedRecipient( const Recipient & ) ) );
  connect( mSideWidget, TQ_SIGNAL( saveDistributionList() ),
    TQ_SLOT( saveDistributionList() ) );
 
  connect( mRecipientsView, TQ_SIGNAL( totalChanged( int, int ) ),
    mSideWidget, TQ_SLOT( setTotal( int, int ) ) );
  connect( mRecipientsView, TQ_SIGNAL( focusRight() ),
    mSideWidget, TQ_SLOT( setFocus() ) );
 
  connect( mRecipientsView, TQ_SIGNAL(sizeHintChanged()),
           TQ_SIGNAL(sizeHintChanged()) );
}
 
RecipientsEditor::~RecipientsEditor()
{
}
 
RecipientsPicker* RecipientsEditor::picker() const
{
  return mSideWidget->picker();
}
 
void RecipientsEditor::slotPickedRecipient( const Recipient &rec )
{
  RecipientLine *line = mRecipientsView->activeLine();
  if ( !line->isEmpty() ) line = mRecipientsView->addLine();
 
  Recipient r = rec;
  if ( r.type() == Recipient::Undefined ) {
    r.setType( line->recipientType() );
  }
 
  line->setRecipient( r );
  mModified = true;
}
 
void RecipientsEditor::saveDistributionList()
{
  DistributionListDialog *dlg = new DistributionListDialog( this );
  dlg->setRecipients( mRecipientsView->recipients() );
  dlg->exec();
  delete dlg;
}
 
Recipient::List RecipientsEditor::recipients() const
{
  return mRecipientsView->recipients();
}
 
void RecipientsEditor::setRecipientString( const TQString &str,
  Recipient::Type type )
{
  clear();
 
  int count = 1;
 
  TQStringList r = KPIM::splitEmailAddrList( str );
  TQStringList::ConstIterator it;
  for( it = r.begin(); it != r.end(); ++it ) {
    if ( count++ > GlobalSettings::self()->maximumRecipients() ) {
      KMessageBox::sorry( this,
        i18n("Truncating recipients list to %1 of %2 entries.")
        .arg( GlobalSettings::self()->maximumRecipients() )
        .arg( r.count() ) );
      break;
    }
    addRecipient( *it, type );
  }
}
 
TQString RecipientsEditor::recipientString( Recipient::Type type )
{
  TQString str;
 
  Recipient::List recipients = mRecipientsView->recipients();
  Recipient::List::ConstIterator it;
  for( it = recipients.begin(); it != recipients.end(); ++it ) {
    if ( (*it).type() == type ) {
      if ( !str.isEmpty() ) str += ", ";
      str.append( (*it).email() );
    }
  }
 
  return str;
}
 
void RecipientsEditor::addRecipient( const TQString & recipient,
                                     Recipient::Type type )
{
  RecipientLine *line = mRecipientsView->emptyLine();
  if ( !line ) line = mRecipientsView->addLine();
  line->setRecipient( Recipient( recipient, type ) );
}
 
void RecipientsEditor::removeRecipient( const TQString & recipient,
                                        Recipient::Type type )
{
  mRecipientsView->removeRecipient( recipient, type );
}
 
bool RecipientsEditor::isModified()
{
  return mModified || mRecipientsView->isModified();
}
 
void RecipientsEditor::clearModified()
{
  mModified = false;
  mRecipientsView->clearModified();
}
 
void RecipientsEditor::clear()
{
}
 
void RecipientsEditor::setFocus()
{
  mRecipientsView->setFocus();
}
 
void RecipientsEditor::setFocusTop()
{
  mRecipientsView->setFocusTop();
}
 
void RecipientsEditor::setFocusBottom()
{
  mRecipientsView->setFocusBottom();
}
 
int RecipientsEditor::setFirstColumnWidth( int w )
{
  return mRecipientsView->setFirstColumnWidth( w );
}
 
void RecipientsEditor::selectRecipients()
{
  mSideWidget->pickRecipient();
}
 
void RecipientsEditor::setCompletionMode( TDEGlobalSettings::Completion mode )
{
  mRecipientsView->setCompletionMode( mode );
}
 
#include "recipientseditor.moc"