diff --git a/akonadi/agentbase.cpp b/akonadi/agentbase.cpp
index c960c7dc7..faf54f816 100644
--- a/akonadi/agentbase.cpp
+++ b/akonadi/agentbase.cpp
@@ -1,628 +1,663 @@
 /*
     Copyright (c) 2006 Till Adam <adam@kde.org>
     Copyright (c) 2007 Volker Krause <vkrause@kde.org>
     Copyright (c) 2007 Bruno Virlet <bruno.virlet@gmail.com>
     Copyright (c) 2008 Kevin Krammer <kevin.krammer@gmx.at>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library 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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "agentbase.h"
 #include "agentbase_p.h"
 
 #include "controladaptor.h"
 #include "statusadaptor.h"
 #include "monitor_p.h"
 #include "xdgbasedirs_p.h"
 
 #include "session.h"
 #include "session_p.h"
 #include "changerecorder.h"
 #include "itemfetchjob.h"
 
 #include <kaboutdata.h>
 #include <kcmdlineargs.h>
 #include <kdebug.h>
 #include <klocale.h>
 #include <kstandarddirs.h>
 
 #include <QtCore/QDir>
 #include <QtCore/QSettings>
 #include <QtCore/QTimer>
 #include <QtGui/QApplication>
 #include <QtDBus/QtDBus>
 
 #include <signal.h>
 #include <stdlib.h>
 
 using namespace Akonadi;
 
 static AgentBase *sAgentBase = 0;
 
 AgentBase::Observer::Observer()
 {
 }
 
 AgentBase::Observer::~Observer()
 {
 }
 
 void AgentBase::Observer::itemAdded( const Item &item, const Collection &collection )
 {
   kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
   Q_UNUSED( item );
   Q_UNUSED( collection );
   if ( sAgentBase != 0 )
     sAgentBase->d_ptr->changeProcessed();
 }
 
 void AgentBase::Observer::itemChanged( const Item &item, const QSet<QByteArray> &partIdentifiers )
 {
   kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
   Q_UNUSED( item );
   Q_UNUSED( partIdentifiers );
   if ( sAgentBase != 0 )
     sAgentBase->d_ptr->changeProcessed();
 }
 
 void AgentBase::Observer::itemRemoved( const Item &item )
 {
   kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
   Q_UNUSED( item );
   if ( sAgentBase != 0 )
     sAgentBase->d_ptr->changeProcessed();
 }
 
 void AgentBase::Observer::collectionAdded( const Akonadi::Collection &collection, const Akonadi::Collection &parent )
 {
   kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
   Q_UNUSED( collection );
   Q_UNUSED( parent );
   if ( sAgentBase != 0 )
     sAgentBase->d_ptr->changeProcessed();
 }
 
 void AgentBase::Observer::collectionChanged( const Collection &collection )
 {
   kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
   Q_UNUSED( collection );
   if ( sAgentBase != 0 )
     sAgentBase->d_ptr->changeProcessed();
 }
 
 void AgentBase::Observer::collectionRemoved( const Collection &collection )
 {
   kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
   Q_UNUSED( collection );
   if ( sAgentBase != 0 )
     sAgentBase->d_ptr->changeProcessed();
 }
 
+void AgentBase::Observer2::itemMoved( const Akonadi::Item &item, const Akonadi::Collection &source, const Akonadi::Collection &dest )
+{
+  kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
+  Q_UNUSED( item );
+  Q_UNUSED( source );
+  Q_UNUSED( dest );
+  if ( sAgentBase != 0 )
+    sAgentBase->d_ptr->changeProcessed();
+}
+
+void AgentBase::Observer2::collectionMoved( const Akonadi::Collection &collection, const Akonadi::Collection &source, const Akonadi::Collection &dest )
+{
+  kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
+  Q_UNUSED( collection );
+  Q_UNUSED( source );
+  Q_UNUSED( dest );
+  if ( sAgentBase != 0 )
+    sAgentBase->d_ptr->changeProcessed();
+}
+
 //@cond PRIVATE
 
 AgentBasePrivate::AgentBasePrivate( AgentBase *parent )
   : q_ptr( parent ),
     mStatusCode( AgentBase::Idle ),
     mProgress( 0 ),
     mNeedsNetwork( false ),
     mOnline( false ),
     mSettings( 0 ),
     mObserver( 0 )
 {
 }
 
 AgentBasePrivate::~AgentBasePrivate()
 {
   mMonitor->setConfig( 0 );
   delete mSettings;
 }
 
 void AgentBasePrivate::init()
 {
   Q_Q( AgentBase );
 
   /**
    * Create a default session for this process.
    */
   SessionPrivate::createDefaultSession( mId.toLatin1() );
 
   mTracer = new org::freedesktop::Akonadi::Tracer( QLatin1String( "org.freedesktop.Akonadi" ), QLatin1String( "/tracing" ),
                                            QDBusConnection::sessionBus(), q );
 
   new ControlAdaptor( q );
   new StatusAdaptor( q );
   if ( !QDBusConnection::sessionBus().registerObject( QLatin1String( "/" ), q, QDBusConnection::ExportAdaptors ) )
     q->error( QString::fromLatin1( "Unable to register object at dbus: %1" ).arg( QDBusConnection::sessionBus().lastError().message() ) );
 
   mSettings = new QSettings( QString::fromLatin1( "%1/agent_config_%2" ).arg( XdgBaseDirs::saveDir( "config", QLatin1String( "akonadi" ) ), mId ), QSettings::IniFormat );
 
   mMonitor = new ChangeRecorder( q );
   mMonitor->ignoreSession( Session::defaultSession() );
   mMonitor->itemFetchScope().setCacheOnly( true );
   mMonitor->setConfig( mSettings );
 
   mOnline = mSettings->value( QLatin1String( "Agent/Online" ), true ).toBool();
 
   mName = mSettings->value( QLatin1String( "Agent/Name" ) ).toString();
   if ( mName.isEmpty() ) {
     mName = mSettings->value( QLatin1String( "Resource/Name" ) ).toString();
     if ( !mName.isEmpty() ) {
       mSettings->remove( QLatin1String( "Resource/Name" ) );
       mSettings->setValue( QLatin1String( "Agent/Name" ), mName );
     }
   }
 
   connect( mMonitor, SIGNAL( itemAdded( const Akonadi::Item&, const Akonadi::Collection& ) ),
            SLOT( itemAdded( const Akonadi::Item&, const Akonadi::Collection& ) ) );
   connect( mMonitor, SIGNAL( itemChanged( const Akonadi::Item&, const QSet<QByteArray>& ) ),
            SLOT( itemChanged( const Akonadi::Item&, const QSet<QByteArray>& ) ) );
   connect( mMonitor, SIGNAL( itemMoved( const Akonadi::Item&, const Akonadi::Collection&, const Akonadi::Collection& ) ),
            SLOT( itemMoved( const Akonadi::Item&, const Akonadi::Collection&, const Akonadi::Collection& ) ) );
   connect( mMonitor, SIGNAL( itemRemoved( const Akonadi::Item& ) ),
            SLOT( itemRemoved( const Akonadi::Item& ) ) );
   connect( mMonitor, SIGNAL( collectionAdded( const Akonadi::Collection&, const Akonadi::Collection& ) ),
            SLOT( collectionAdded( const Akonadi::Collection&, const Akonadi::Collection& ) ) );
   connect( mMonitor, SIGNAL( collectionChanged( const Akonadi::Collection& ) ),
            SLOT( collectionChanged( const Akonadi::Collection& ) ) );
   connect( mMonitor, SIGNAL(collectionMoved(Akonadi::Collection,Akonadi::Collection,Akonadi::Collection)),
            SLOT(collectionMoved(Akonadi::Collection,Akonadi::Collection,Akonadi::Collection)) );
   connect( mMonitor, SIGNAL( collectionRemoved( const Akonadi::Collection& ) ),
            SLOT( collectionRemoved( const Akonadi::Collection& ) ) );
 
   connect( q, SIGNAL( status( int, const QString& ) ), q, SLOT( slotStatus( int, const QString& ) ) );
   connect( q, SIGNAL( percent( int ) ), q, SLOT( slotPercent( int ) ) );
   connect( q, SIGNAL( warning( const QString& ) ), q, SLOT( slotWarning( const QString& ) ) );
   connect( q, SIGNAL( error( const QString& ) ), q, SLOT( slotError( const QString& ) ) );
 
   // Use reference counting to allow agents to finish internal jobs when the
   // agent is stopped.
   KGlobal::ref();
   KGlobal::setAllowQuit(true);
 
   QTimer::singleShot( 0, q, SLOT( delayedInit() ) );
 }
 
 void AgentBasePrivate::delayedInit()
 {
   Q_Q( AgentBase );
   if ( !QDBusConnection::sessionBus().registerService( QLatin1String( "org.freedesktop.Akonadi.Agent." ) + mId ) )
     kFatal() << "Unable to register service at dbus:" << QDBusConnection::sessionBus().lastError().message();
   q->setOnline( mOnline );
 }
 
 void AgentBasePrivate::itemAdded( const Akonadi::Item &item, const Akonadi::Collection &collection )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
   if ( mObserver != 0 )
     mObserver->itemAdded( item, collection );
 }
 
 void AgentBasePrivate::itemChanged( const Akonadi::Item &item, const QSet<QByteArray> &partIdentifiers )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
   if ( mObserver != 0 )
     mObserver->itemChanged( item, partIdentifiers );
 }
 
 void AgentBasePrivate::itemMoved( const Akonadi::Item &item, const Akonadi::Collection &source, const Akonadi::Collection &dest )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
+  AgentBase::Observer2 *observer2 = dynamic_cast<AgentBase::Observer2*>( mObserver );
   if ( mObserver ) {
     // inter-resource moves, requires we know which resources the source and destination are in though
     if ( !source.resource().isEmpty() && !dest.resource().isEmpty() ) {
       if ( source.resource() != dest.resource() ) {
         if ( source.resource() == q_ptr->identifier() ) // moved away from us
           mObserver->itemRemoved( item );
         else if ( dest.resource() == q_ptr->identifier() ) // moved to us
           mObserver->itemAdded( item, dest );
-        else // not for us, not sure if we should get here at all
+        else if ( observer2 )
+          observer2->itemMoved( item, source, dest );
+        else
+          // not for us, not sure if we should get here at all
           changeProcessed();
         return;
       }
     }
-    // either incomplete information or intra-resource move
-    // ### we cannot just call itemRemoved here as this will already trigger changeProcessed()
-    // so, just itemAdded() is good enough as no resource can have implemented intra-resource moves anyway
-    // without using Observer2
-    mObserver->itemAdded( item, dest );
-    // mObserver->itemRemoved( item );
+    // intra-resource move
+    if ( observer2 ) {
+      observer2->itemMoved( item, source, dest );
+    } else {
+      // ### we cannot just call itemRemoved here as this will already trigger changeProcessed()
+      // so, just itemAdded() is good enough as no resource can have implemented intra-resource moves anyway
+      // without using Observer2
+      mObserver->itemAdded( item, dest );
+      // mObserver->itemRemoved( item );
+    }
   }
 }
 
 void AgentBasePrivate::itemRemoved( const Akonadi::Item &item )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
   if ( mObserver != 0 )
     mObserver->itemRemoved( item );
 }
 
 void AgentBasePrivate::collectionAdded( const Akonadi::Collection &collection, const Akonadi::Collection &parent )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
   if ( mObserver != 0 )
     mObserver->collectionAdded( collection, parent );
 }
 
 void AgentBasePrivate::collectionChanged( const Akonadi::Collection &collection )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
   if ( mObserver != 0 )
     mObserver->collectionChanged( collection );
 }
 
 void AgentBasePrivate::collectionMoved( const Akonadi::Collection &collection, const Akonadi::Collection &source, const Akonadi::Collection &dest )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
+  AgentBase::Observer2 *observer2 = dynamic_cast<AgentBase::Observer2*>( mObserver );
   if ( mObserver ) {
     // inter-resource moves, requires we know which resources the source and destination are in though
     if ( !source.resource().isEmpty() && !dest.resource().isEmpty() ) {
       if ( source.resource() != dest.resource() ) {
         if ( source.resource() == q_ptr->identifier() ) // moved away from us
           mObserver->collectionRemoved( collection );
         else if ( dest.resource() == q_ptr->identifier() ) // moved to us
           mObserver->collectionAdded( collection, dest );
+        else if ( observer2 )
+          observer2->collectionMoved( collection, source, dest );
         else // not for us, not sure if we should get here at all
           changeProcessed();
         return;
       }
     }
-    // either incomplete information or intra-resource move
-    // ### we cannot just call collectionRemoved here as this will already trigger changeProcessed()
-    // so, just collectionAdded() is good enough as no resource can have implemented intra-resource moves anyway
-    // without using Observer2
-    mObserver->collectionAdded( collection, dest );
+    // intra-resource move
+    if ( observer2 ) {
+      observer2->collectionMoved( collection, source, dest );
+    } else {
+      // ### we cannot just call collectionRemoved here as this will already trigger changeProcessed()
+      // so, just collectionAdded() is good enough as no resource can have implemented intra-resource moves anyway
+      // without using Observer2
+      mObserver->collectionAdded( collection, dest );
+    }
   }
 }
 
 void AgentBasePrivate::collectionRemoved( const Akonadi::Collection &collection )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
   if ( mObserver != 0 )
     mObserver->collectionRemoved( collection );
 }
 
 void AgentBasePrivate::changeProcessed()
 {
   mMonitor->changeProcessed();
   QTimer::singleShot( 0, mMonitor, SLOT( replayNext() ) );
 }
 
 void AgentBasePrivate::slotStatus( int status, const QString &message )
 {
   mStatusMessage = message;
   mStatusCode = 0;
 
   switch ( status ) {
     case AgentBase::Idle:
       if ( mStatusMessage.isEmpty() )
         mStatusMessage = defaultReadyMessage();
 
       mStatusCode = 0;
       break;
     case AgentBase::Running:
       if ( mStatusMessage.isEmpty() )
         mStatusMessage = defaultSyncingMessage();
 
       mStatusCode = 1;
       break;
     case AgentBase::Broken:
       if ( mStatusMessage.isEmpty() )
         mStatusMessage = defaultErrorMessage();
 
       mStatusCode = 2;
       break;
     default:
       Q_ASSERT( !"Unknown status passed" );
       break;
   }
 }
 
 void AgentBasePrivate::slotPercent( int progress )
 {
   mProgress = progress;
 }
 
 void AgentBasePrivate::slotWarning( const QString& message )
 {
   mTracer->warning( QString::fromLatin1( "AgentBase(%1)" ).arg( mId ), message );
 }
 
 void AgentBasePrivate::slotError( const QString& message )
 {
   mTracer->error( QString::fromLatin1( "AgentBase(%1)" ).arg( mId ), message );
 }
 
 void AgentBasePrivate::slotNetworkStatusChange( Solid::Networking::Status stat )
 {
   Q_Q( AgentBase );
   q->setOnline( stat == Solid::Networking::Connected );
 }
 
 
 AgentBase::AgentBase( const QString & id )
   : d_ptr( new AgentBasePrivate( this ) )
 {
   sAgentBase = this;
   d_ptr->mId = id;
   d_ptr->init();
   if ( KApplication::kApplication() )
     KApplication::kApplication()->disableSessionManagement();
 }
 
 AgentBase::AgentBase( AgentBasePrivate* d, const QString &id ) :
     d_ptr( d )
 {
   sAgentBase = this;
   d_ptr->mId = id;
   d_ptr->init();
 }
 
 AgentBase::~AgentBase()
 {
   delete d_ptr;
 }
 
 QString AgentBase::parseArguments( int argc, char **argv )
 {
   QString identifier;
   if ( argc < 3 ) {
     kDebug() << "Not enough arguments passed...";
     exit( 1 );
   }
 
   for ( int i = 1; i < argc - 1; ++i ) {
     if ( QLatin1String( argv[ i ] ) == QLatin1String( "--identifier" ) )
       identifier = QLatin1String( argv[ i + 1 ] );
   }
 
   if ( identifier.isEmpty() ) {
     kDebug() << "Identifier argument missing";
     exit( 1 );
   }
 
   QByteArray catalog;
   char *p = strrchr( argv[0], '/' );
   if ( p )
     catalog = QByteArray( p + 1 );
   else
     catalog = QByteArray( argv[0] );
 
   KCmdLineArgs::init( argc, argv, identifier.toLatin1(), catalog, ki18n("Akonadi Agent"),"0.1" ,
                       ki18n("Akonadi Agent") );
 
   KCmdLineOptions options;
   options.add("identifier <argument>", ki18n("Agent identifier"));
   KCmdLineArgs::addCmdLineOptions( options );
 
   return identifier;
 }
 
 // @endcond
 
 int AgentBase::init( AgentBase *r )
 {
   QApplication::setQuitOnLastWindowClosed( false );
   KGlobal::locale()->insertCatalog( QLatin1String("libakonadi") );
   int rv = kapp->exec();
   delete r;
   return rv;
 }
 
 int AgentBase::status() const
 {
   Q_D( const AgentBase );
 
   return d->mStatusCode;
 }
 
 QString AgentBase::statusMessage() const
 {
   Q_D( const AgentBase );
 
   return d->mStatusMessage;
 }
 
 int AgentBase::progress() const
 {
   Q_D( const AgentBase );
 
   return d->mProgress;
 }
 
 QString AgentBase::progressMessage() const
 {
   Q_D( const AgentBase );
 
   return d->mProgressMessage;
 }
 
 bool AgentBase::isOnline() const
 {
   Q_D( const AgentBase );
 
   return d->mOnline;
 }
 
 void AgentBase::setNeedsNetwork( bool needsNetwork )
 {
   Q_D( AgentBase );
   d->mNeedsNetwork = needsNetwork;
 
   if ( d->mNeedsNetwork ) {
     connect( Solid::Networking::notifier()
            , SIGNAL( statusChanged( Solid::Networking::Status ) )
            , this, SLOT( slotNetworkStatusChange( Solid::Networking::Status ) ) );
   } else {
     disconnect( Solid::Networking::notifier(), 0, 0, 0 );
     setOnline( true );
   }
 }
 
 void AgentBase::setOnline( bool state )
 {
   Q_D( AgentBase );
   d->mOnline = state;
   d->mSettings->setValue( QLatin1String( "Agent/Online" ), state );
   doSetOnline( state );
   emit onlineChanged( state );
 }
 
 void AgentBase::doSetOnline( bool online )
 {
   Q_UNUSED( online );
 }
 
 void AgentBase::configure( WId windowId )
 {
   Q_UNUSED( windowId );
 }
 
 #ifdef Q_OS_WIN //krazy:exclude=cpp
 void AgentBase::configure( qlonglong windowId )
 {
   configure( reinterpret_cast<WId>( windowId ) );
 }
 #endif
 
 WId AgentBase::winIdForDialogs() const
 {
   bool registered = QDBusConnection::sessionBus().interface()->isServiceRegistered( QLatin1String("org.freedesktop.akonaditray") );
   if ( !registered )
     return 0;
 
   QDBusInterface dbus( QLatin1String("org.freedesktop.akonaditray"), QLatin1String("/Actions"),
                        QLatin1String("org.freedesktop.Akonadi.Tray") );
   QDBusMessage reply = dbus.call( QLatin1String("getWinId") );
 
   if ( reply.type() == QDBusMessage::ErrorMessage )
     return 0;
 
   WId winid = (WId)reply.arguments().at( 0 ).toLongLong();
   return winid;
 }
 
 void AgentBase::quit()
 {
   Q_D( AgentBase );
   aboutToQuit();
 
   if ( d->mSettings ) {
     d->mMonitor->setConfig( 0 );
     d->mSettings->sync();
   }
 
   KGlobal::deref();
 }
 
 void AgentBase::aboutToQuit()
 {
 }
 
 void AgentBase::cleanup()
 {
   Q_D( AgentBase );
   // prevent the monitor from picking up deletion signals for our own data if we are a resource
   // and thus avoid that we kill our own data as last act before our own death
   d->mMonitor->blockSignals( true );
 
   aboutToQuit();
 
   const QString fileName = d->mSettings->fileName();
 
   /*
    * First destroy the settings object...
    */
   d->mMonitor->setConfig( 0 );
   delete d->mSettings;
   d->mSettings = 0;
 
   /*
    * ... then remove the file from hd.
    */
   QFile::remove( fileName );
 
   /*
    * ... and also remove the agent configuration file if there is one.
    */
   QString configFile = KStandardDirs::locateLocal( "config", KGlobal::config()->name() );
   QFile::remove( configFile );
 
   KGlobal::deref();
 }
 
 void AgentBase::registerObserver( Observer *observer )
 {
   kDebug() << "observer=" << (void*) observer << "this=" << (void*) this;
   d_ptr->mObserver = observer;
 }
 
 QString AgentBase::identifier() const
 {
   return d_ptr->mId;
 }
 
 void AgentBase::setAgentName( const QString &name )
 {
   Q_D( AgentBase );
   if ( name == d->mName )
     return;
 
   // TODO: rename collection
   d->mName = name;
 
   if ( d->mName.isEmpty() || d->mName == d->mId ) {
     d->mSettings->remove( QLatin1String( "Resource/Name" ) );
     d->mSettings->remove( QLatin1String( "Agent/Name" ) );
   } else
     d->mSettings->setValue( QLatin1String( "Agent/Name" ), d->mName );
 
   d->mSettings->sync();
 
   emit agentNameChanged( d->mName );
 }
 
 QString AgentBase::agentName() const
 {
   Q_D( const AgentBase );
   if ( d->mName.isEmpty() )
     return d->mId;
   else
     return d->mName;
 }
 
 void AgentBase::changeProcessed()
 {
   Q_D( AgentBase );
   d->changeProcessed();
 }
 
 ChangeRecorder * AgentBase::changeRecorder() const
 {
   return d_ptr->mMonitor;
 }
 
 void AgentBase::abort()
 {
   emit abortRequested();
 }
 
 void AgentBase::reconfigure()
 {
   emit reloadConfiguration();
 }
 
 #include "agentbase.moc"
 #include "agentbase_p.moc"
diff --git a/akonadi/agentbase.h b/akonadi/agentbase.h
index fb6a94859..6914a4044 100644
--- a/akonadi/agentbase.h
+++ b/akonadi/agentbase.h
@@ -1,509 +1,547 @@
 /*
     This file is part of akonadiresources.
 
     Copyright (c) 2006 Till Adam <adam@kde.org>
     Copyright (c) 2007 Volker Krause <vkrause@kde.org>
     Copyright (c) 2008 Kevin Krammer <kevin.krammer@gmx.at>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library 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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #ifndef AKONADI_AGENTBASE_H
 #define AKONADI_AGENTBASE_H
 
 #include "akonadi_export.h"
 
 #include <KDE/KApplication>
 
 #include <QtDBus/QDBusContext>
 
 class ControlAdaptor;
 class StatusAdaptor;
 
 namespace Akonadi {
 
 class AgentBasePrivate;
 class ChangeRecorder;
 class Collection;
 class Item;
 class Session;
 
 /**
  * @short The base class for all Akonadi agents and resources.
  *
  * This class is a base class for all Akonadi agents, which covers the real
  * agent processes and all resources.
  *
  * It provides:
  * - lifetime management
  * - change monitoring and recording
  * - configuration interface
  * - problem reporting
  *
  * @author Till Adam <adam@kde.org>, Volker Krause <vkrause@kde.org>
  */
 class AKONADI_EXPORT AgentBase : public QObject, protected QDBusContext
 {
   Q_OBJECT
 
   public:
     /**
      * @short The interface for reacting on monitored or replayed changes.
      *
      * The Observer provides an interface to react on monitored or replayed changes.
      *
      * Since the this base class does only tell the change recorder that the change
      * has been processed, an AgentBase subclass which wants to actually process
      * the change needs to subclass Observer and reimplement the methods it is
      * interested in.
      *
      * Such an agent specific Observer implementation can either be done
      * stand-alone, i.e. as a separate object, or by inheriting both AgentBase
      * and AgentBase::Observer.
      *
      * The observer implementation then has registered with the agent, so it
      * can forward the incoming changes to the observer.
      *
      * @note In the multiple inheritance approach the init() method automatically
      *       registers itself as the observer.
      *
      * Example for stand-alone observer:
      * @code
      * class ExampleAgent : public AgentBase
      * {
      *   public:
      *     ExampleAgent( const QString &id );
      *
      *     ~ExampleAgent();
      *
      *   private:
      *     AgentBase::Observer *mObserver;
      * };
      *
      * class ExampleObserver : public AgentBase::Observer
      * {
      *   protected:
      *     void itemChanged( const Item &item );
      * };
      *
      * ExampleAgent::ExampleAgent( const QString &id )
      *   : AgentBase( id ), mObserver( 0 )
      * {
      *   mObserver = new ExampleObserver();
      *   registerObserver( mObserver );
      * }
      *
      * ExampleAgent::~ExampleAgent()
      * {
      *   delete mObserver;
      * }
      *
      * void ExampleObserver::itemChanged( const Item &item )
      * {
      *   // do something with item
      *   kDebug() << "Item id=" << item.id();
      *
      *   // let base implementation tell the change recorder that we
      *   // have processed the change
      *   AgentBase::Observer::itemChanged( item );
      * }
      * @endcode
      *
      * Example for observer through multiple inheritance:
      * @code
      * class ExampleAgent : public AgentBase, public AgentBase::Observer
      * {
      *   public:
      *     ExampleAgent( const QString &id );
      *
      *   protected:
      *     void itemChanged( const Item &item );
      * };
      *
      * ExampleAgent::ExampleAgent( const QString &id )
      *   : AgentBase( id )
      * {
      *   // no need to create or register observer since
      *   // we are the observer and registration happens automatically
      *   // in init()
      * }
      *
      * void ExampleAgent::itemChanged( const Item &item )
      * {
      *   // do something with item
      *   kDebug() << "Item id=" << item.id();
      *
      *   // let base implementation tell the change recorder that we
      *   // have processed the change
      *   AgentBase::Observer::itemChanged( item );
      * }
      * @endcode
      *
      * @author Kevin Krammer <kevin.krammer@gmx.at>
+     *
+     * @deprecated Use Observer2 instead
      */
     class AKONADI_EXPORT Observer  // krazy:exclude=dpointer
     {
       public:
         /**
          * Creates an observer instance.
          */
         Observer();
 
         /**
          * Destroys the observer instance.
          */
         virtual ~Observer();
 
         /**
          * Reimplement to handle adding of new items.
          * @param item The newly added item.
          * @param collection The collection @p item got added to.
          */
         virtual void itemAdded( const Akonadi::Item &item, const Akonadi::Collection &collection );
 
         /**
          * Reimplement to handle changes to existing items.
          * @param item The changed item.
          * @param partIdentifiers The identifiers of the item parts that has been changed.
          */
         virtual void itemChanged( const Akonadi::Item &item, const QSet<QByteArray> &partIdentifiers );
 
         /**
          * Reimplement to handle deletion of items.
          * @param item The deleted item.
          */
         virtual void itemRemoved( const Akonadi::Item &item );
 
         /**
          * Reimplement to handle adding of new collections.
          * @param collection The newly added collection.
          * @param parent The parent collection.
           */
         virtual void collectionAdded( const Akonadi::Collection &collection, const Akonadi::Collection &parent );
 
         /**
          * Reimplement to handle changes to existing collections.
          * @param collection The changed collection.
          */
         virtual void collectionChanged( const Akonadi::Collection &collection );
 
         /**
          * Reimplement to handle deletion of collections.
          * @param collection The deleted collection.
          */
         virtual void collectionRemoved( const Akonadi::Collection &collection );
     };
 
+    /**
+     * BC extension of Observer with support for monitoring item and collection moves.
+     * Use this one instead of Observer.
+     *
+     * @since 4.4
+     */
+    class AKONADI_EXPORT Observer2 : public Observer  // krazy:exclude=dpointer
+    {
+      public:
+        /**
+         * Reimplement to handle item moves.
+         * When using this class in combination with Akonadi::ResourceBase, inter-resource
+         * moves are handled internally already and the corresponding  add or delete method
+         * is called instead.
+         *
+         * @param item The moved item.
+         * @param collectionSource The collection the item has been moved from.
+         * @param collectionDestination The collection the item has been moved to.
+         */
+        virtual void itemMoved( const Akonadi::Item &item, const Akonadi::Collection &collectionSource,
+                                const Akonadi::Collection &collectionDestination );
+
+        /**
+         * Reimplement to handle collection moves.
+         * When using this class in combination with Akonadi::ResourceBase, inter-resource
+         * moves are handled internally already and the corresponding  add or delete method
+         * is called instead.
+         *
+         * @param collection The moved collection.
+         * @param source The previous parent collection.
+         * @param distination The new parent collection.
+         */
+        virtual void collectionMoved( const Akonadi::Collection &collection, const Akonadi::Collection &source,
+                                      const Akonadi::Collection &destination );
+    };
+
     /**
      * This enum describes the different states the
      * agent can be in.
      */
     enum Status
     {
       Idle = 0, ///< The agent does currently nothing.
       Running,  ///< The agent is working on something.
       Broken    ///< The agent encountered an error state.
     };
 
     /**
      * Use this method in the main function of your agent
      * application to initialize your agent subclass.
      * This method also takes care of creating a KApplication
      * object and parsing command line arguments.
      *
      * @note In case the given class is also derived from AgentBase::Observer
      *       it gets registered as its own observer (see AgentBase::Observer), e.g.
      *       <tt>agentInstance->registerObserver( agentInstance );</tt>
      *
      * @code
      *
      *   class MyAgent : public AgentBase
      *   {
      *     ...
      *   };
      *
      *   AKONADI_AGENT_MAIN( MyAgent )
      *
      * @endcode
      */
     template <typename T>
     static int init( int argc, char **argv )
     {
       const QString id = parseArguments( argc, argv );
       KApplication app;
       T* r = new T( id );
 
       // check if T also inherits AgentBase::Observer and
       // if it does, automatically register it on itself
       Observer *observer = dynamic_cast<Observer*>( r );
       if ( observer != 0 )
         r->registerObserver( observer );
       return init( r );
     }
 
     /**
      * This method returns the current status code of the agent.
      *
      * The following return values are possible:
      *
      *  - 0 - Idle
      *  - 1 - Running
      *  - 2 - Broken
      */
     virtual int status() const;
 
     /**
      * This method returns an i18n'ed description of the current status code.
      */
     virtual QString statusMessage() const;
 
     /**
      * This method returns the current progress of the agent in percentage.
      */
     virtual int progress() const;
 
     /**
      * This method returns an i18n'ed description of the current progress.
      */
     virtual QString progressMessage() const;
 
     /**
      * This method is called whenever the agent shall show its configuration dialog
      * to the user. It will be automatically called when the agent is started for
      * the first time.
      * @param windowId The parent window id.
      */
     virtual void configure( WId windowId );
 
     /**
      * This method returns the windows id, which should be used for dialogs.
      */
     WId winIdForDialogs() const;
 
 #ifdef Q_OS_WIN
     /**
      * Overload of @ref configure needed because WId cannot be automatically casted
      * to qlonglong on Windows.
      */
     void configure( qlonglong windowId );
 #endif
 
     /**
      * Returns the instance identifier of this agent.
      */
     QString identifier() const;
 
     /**
      * This method is called when the agent is removed from
      * the system, so it can do some cleanup stuff.
      */
     virtual void cleanup();
 
     /**
      * Registers the given observer for reacting on monitored or recorded changes.
      *
      * @param observer The change handler to register. No ownership transfer, i.e.
      *                 the caller stays owner of the pointer and can reset
      *                 the registration by calling this method with @c 0
      */
     void registerObserver( Observer *observer );
 
     /**
      * This method is used to set the name of the agent.
      *
      * @since 4.3
      */
     //FIXME_API: make sure location is renamed to this by agentbase
     void setAgentName( const QString &name );
 
     /**
      * Returns the name of the agent.
      *
      * @since 4.3
      */
     QString agentName() const;
 
   Q_SIGNALS:
     /**
      * This signal is emitted whenever the name of the agent has changed.
      *
      * @param name The new name of the agent.
      *
      * @since 4.3
      */
     void agentNameChanged( const QString &name );
 
     /**
      * This signal should be emitted whenever the status of the agent has been changed.
      * @param status The new Status code.
      * @param message A i18n'ed description of the new status.
      */
     void status( int status, const QString &message = QString() );
 
     /**
      * This signal should be emitted whenever the progress of an action in the agent
      * (e.g. data transfer, connection establishment to remote server etc.) has changed.
      *
      * @param progress The progress of the action in percent.
      */
     void percent( int progress );
 
     /**
      * This signal shall be used to report warnings.
      *
      * @param message The i18n'ed warning message.
      */
     void warning( const QString& message );
 
     /**
      * This signal shall be used to report errors.
      *
      * @param message The i18n'ed error message.
      */
     void error( const QString& message );
 
     /**
      * Emitted when another application has remotely asked the agent to abort
      * its current operation.
      * Connect to this signal if your agent supports abortion. After aborting
      * and cleaning up, agents should return to Idle status.
      *
      * @since 4.4
      */
     void abortRequested();
 
     /**
      * Emitted if another application has changed the agent's configuration remotely
      * and called AgentInstance::reconfigure().
      *
      * @since 4.2
      */
     void reloadConfiguration();
 
     /**
      * Emitted when the online state changed.
      * @param state The online state.
      * @since 4.2
      */
     void onlineChanged( bool b );
 
   protected:
     /**
      * Creates an agent base.
      *
      * @param id The instance id of the agent.
      */
     AgentBase( const QString & id );
 
     /**
      * Destroys the agent base.
      */
     ~AgentBase();
 
     /**
      * This method is called whenever the agent application is about to
      * quit.
      *
      * Reimplement this method to do session cleanup (e.g. disconnecting
      * from groupware server).
      */
     virtual void aboutToQuit();
 
     /**
      * Returns the Akonadi::ChangeRecorder object used for monitoring.
      * Use this to configure which parts you want to monitor.
      */
     ChangeRecorder* changeRecorder() const;
 
     /**
      * Marks the current change as processes and replays the next change if change
      * recording is enabled (noop otherwise). This method is called
      * from the default implementation of the change notification slots. While not
      * required when not using change recording, it is nevertheless recommended
      * to call this method when done with processing a change notification.
      */
     void changeProcessed();
 
     /**
      * Returns whether the agent is currently online.
      */
     bool isOnline() const;
 
     /**
      * Sets whether the agent needs network or not.
      *
      * @since 4.2
      * @todo use this in combination with Solid::Networking::Notifier to change
      *       the onLine status of the agent.
      */
     void setNeedsNetwork( bool needsNetwork );
 
     /**
      * Sets whether the agent shall be online or not.
      */
     void setOnline( bool state );
 
   protected:
     //@cond PRIVATE
     AgentBasePrivate *d_ptr;
     explicit AgentBase( AgentBasePrivate* d, const QString &id );
     //@endcond
 
     /**
      * This method is called whenever the @p online status has changed.
      * Reimplement this method to react on online status changes.
      */
     virtual void doSetOnline( bool online );
 
   private:
     //@cond PRIVATE
     static QString parseArguments( int, char** );
     static int init( AgentBase *r );
 
     // D-Bus interface stuff
     void abort();
     void reconfigure();
     void quit();
 
     // dbus agent interface
     friend class ::StatusAdaptor;
     friend class ::ControlAdaptor;
 
     Q_DECLARE_PRIVATE( AgentBase )
     Q_PRIVATE_SLOT( d_func(), void delayedInit() )
     Q_PRIVATE_SLOT( d_func(), void slotStatus( int, const QString& ) )
     Q_PRIVATE_SLOT( d_func(), void slotPercent( int ) )
     Q_PRIVATE_SLOT( d_func(), void slotWarning( const QString& ) )
     Q_PRIVATE_SLOT( d_func(), void slotError( const QString& ) )
     Q_PRIVATE_SLOT( d_func(), void slotNetworkStatusChange( Solid::Networking::Status ) )
 
     //@endcond
 };
 
 }
 
 #ifndef AKONADI_AGENT_MAIN
 /**
  * Convenience Macro for the most common main() function for Akonadi agents.
  */
 #define AKONADI_AGENT_MAIN( agentClass )                       \
   int main( int argc, char **argv )                            \
   {                                                            \
     return Akonadi::AgentBase::init<agentClass>( argc, argv ); \
   }
 #endif
 
 #endif