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

25 files changed, 3115 insertions, 0 deletions

diff --git a/kitchensync/libqopensync/Makefile.am b/kitchensync/libqopensync/Makefile.am
new file mode 100644
index 000000000..2e12df6ca
--- /dev/null
+++ b/kitchensync/libqopensync/Makefile.am
@@ -0,0 +1,19 @@
+INCLUDES = -I$(top_srcdir)/kitchensync/src \
+           -I$(top_srcdir)/kitchensync \
+           -I$(top_srcdir) \
+           $(OPENSYNC_CFLAGS) \
+           $(OPENSYNCENGINE_CFLAGS) \
+           $(all_includes)
+
+lib_LTLIBRARIES = libqopensync.la
+
+libqopensync_la_SOURCES = callbackhandler.cpp conversion.cpp engine.cpp environment.cpp filter.cpp group.cpp \
+	member.cpp plugin.cpp result.cpp syncmapping.cpp syncupdates.cpp \
+	syncchange.cpp
+libqopensync_la_LDFLAGS = $(all_libraries) $(KDE_RPATH) -no-undefined
+libqopensync_la_LIBADD = $(LIB_KDEUI) $(OPENSYNC_LIBS) $(OPENSYNCENGINE_LIBS)
+
+METASOURCES = AUTO
+
+messages: rc.cpp
+	$(XGETTEXT) *.cpp *.h -o $(podir)/libqopensync.pot
diff --git a/kitchensync/libqopensync/callbackhandler.cpp b/kitchensync/libqopensync/callbackhandler.cpp
new file mode 100644
index 000000000..86f279f14
--- /dev/null
+++ b/kitchensync/libqopensync/callbackhandler.cpp
@@ -0,0 +1,191 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 <osengine/engine.h>
+
+#include <libqopensync/engine.h>
+
+#include <qapplication.h>
+
+#include "callbackhandler.h"
+
+using namespace QSync;
+
+class CallbackHandler::ConflictEvent : public QCustomEvent
+{
+  public:
+    ConflictEvent( const SyncMapping& mapping )
+      : QCustomEvent( ConflictEventType ), mMapping( mapping )
+    {
+    }
+
+    SyncMapping mapping() const { return mMapping; }
+
+  private:
+    SyncMapping mMapping;
+};
+
+class CallbackHandler::ChangeEvent : public QCustomEvent
+{
+  public:
+    ChangeEvent( const SyncChangeUpdate& change )
+      : QCustomEvent( ChangeEventType ), mChange( change )
+    {
+    }
+
+    SyncChangeUpdate change() const { return mChange; }
+
+  private:
+    SyncChangeUpdate mChange;
+};
+
+class CallbackHandler::MappingEvent : public QCustomEvent
+{
+  public:
+    MappingEvent( const SyncMappingUpdate& mapping )
+      : QCustomEvent( MappingEventType ), mMapping( mapping )
+    {
+    }
+
+    SyncMappingUpdate mapping() const { return mMapping; }
+
+  private:
+    SyncMappingUpdate mMapping;
+};
+
+class CallbackHandler::EngineEvent : public QCustomEvent
+{
+  public:
+    EngineEvent( const SyncEngineUpdate& engine )
+      : QCustomEvent( EngineEventType ), mEngine( engine )
+    {
+    }
+
+    SyncEngineUpdate engine() const { return mEngine; }
+
+  private:
+    SyncEngineUpdate mEngine;
+};
+
+class CallbackHandler::MemberEvent : public QCustomEvent
+{
+  public:
+    MemberEvent( const SyncMemberUpdate& member )
+      : QCustomEvent( MemberEventType ), mMember( member )
+    {
+    }
+
+    SyncMemberUpdate member() const { return mMember; }
+
+  private:
+    SyncMemberUpdate mMember;
+};
+
+CallbackHandler::CallbackHandler()
+{
+}
+
+CallbackHandler::~CallbackHandler()
+{
+}
+
+void CallbackHandler::setEngine( Engine *engine )
+{
+  mEngine = engine;
+
+  osengine_set_conflict_callback( engine->mEngine, &conflict_callback, this );
+  osengine_set_changestatus_callback( engine->mEngine, &change_callback, this );
+  osengine_set_mappingstatus_callback( engine->mEngine, &mapping_callback, this );
+  osengine_set_enginestatus_callback( engine->mEngine, &engine_callback, this );
+  osengine_set_memberstatus_callback( engine->mEngine, &member_callback, this );
+}
+
+Engine* CallbackHandler::engine() const
+{
+  return mEngine;
+}
+
+void CallbackHandler::customEvent( QCustomEvent *event )
+{
+  if ( event->type() == static_cast<QEvent::Type>( ConflictEventType ) ) {
+    ConflictEvent *conflictEvent = static_cast<ConflictEvent*>( event );
+    emit conflict( conflictEvent->mapping() );
+  } else if ( event->type() == static_cast<QEvent::Type>( ChangeEventType ) ) {
+    ChangeEvent *changeEvent = static_cast<ChangeEvent*>( event );
+    emit change( changeEvent->change() );
+  } else if ( event->type() == static_cast<QEvent::Type>( MappingEventType ) ) {
+    MappingEvent *mappingEvent = static_cast<MappingEvent*>( event );
+    emit mapping( mappingEvent->mapping() );
+  } else if ( event->type() == static_cast<QEvent::Type>( EngineEventType ) ) {
+    EngineEvent *engineEvent = static_cast<EngineEvent*>( event );
+    emit engine( engineEvent->engine() );
+  } else if ( event->type() == static_cast<QEvent::Type>( MemberEventType ) ) {
+    MemberEvent *memberEvent = static_cast<MemberEvent*>( event );
+    emit member( memberEvent->member() );
+  }
+}
+
+void CallbackHandler::conflict_callback( OSyncEngine *engine, OSyncMapping *omapping, void *data )
+{
+  SyncMapping mapping( omapping, engine );
+
+  CallbackHandler *handler = static_cast<CallbackHandler*>( data );
+
+  QApplication::postEvent( handler, new ConflictEvent( mapping ) );
+}
+
+void CallbackHandler::change_callback( OSyncEngine*, OSyncChangeUpdate *update, void *data )
+{
+  SyncChangeUpdate change( update );
+
+  CallbackHandler *handler = static_cast<CallbackHandler*>( data );
+
+  QApplication::postEvent( handler, new ChangeEvent( change ) );
+}
+
+void CallbackHandler::mapping_callback( OSyncMappingUpdate *update, void *data )
+{
+  CallbackHandler *handler = static_cast<CallbackHandler*>( data );
+
+  SyncMappingUpdate mapping( update, handler->engine()->mEngine );
+
+  QApplication::postEvent( handler, new MappingEvent( mapping ) );
+}
+
+void CallbackHandler::engine_callback( OSyncEngine*, OSyncEngineUpdate *update, void *data )
+{
+  SyncEngineUpdate engine( update );
+
+  CallbackHandler *handler = static_cast<CallbackHandler*>( data );
+
+  QApplication::postEvent( handler, new EngineEvent( engine ) );
+}
+
+void CallbackHandler::member_callback( OSyncMemberUpdate *update, void *data )
+{
+  SyncMemberUpdate member( update );
+
+  CallbackHandler *handler = static_cast<CallbackHandler*>( data );
+
+  QApplication::postEvent( handler, new MemberEvent( member ) );
+}
+
+#include "callbackhandler.moc"
diff --git a/kitchensync/libqopensync/callbackhandler.h b/kitchensync/libqopensync/callbackhandler.h
new file mode 100644
index 000000000..a31132559
--- /dev/null
+++ b/kitchensync/libqopensync/callbackhandler.h
@@ -0,0 +1,90 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 QSYNC_CALLBACKHANDLER_H
+#define QSYNC_CALLBACKHANDLER_H
+
+#include <libqopensync/syncmapping.h>
+#include <libqopensync/syncupdates.h>
+
+#include <qobject.h>
+
+class OSyncEngine;
+class OSyncMapping;
+class OSyncChangeUpdate;
+class OSyncMappingUpdate;
+class OSyncEngineUpdate;
+class OSyncMemberUpdate;
+
+class QCustomEvent;
+
+namespace QSync {
+
+class Engine;
+
+class CallbackHandler : public QObject
+{
+  Q_OBJECT
+
+  public:
+    CallbackHandler();
+    ~CallbackHandler();
+
+    void setEngine( Engine *engine );
+    Engine* engine() const;
+
+  signals:
+    void conflict( QSync::SyncMapping mapping );
+    void change( const QSync::SyncChangeUpdate &update );
+    void mapping( const QSync::SyncMappingUpdate &update );
+    void engine( const QSync::SyncEngineUpdate &update );
+    void member( const QSync::SyncMemberUpdate &update );
+
+  protected:
+    virtual void customEvent( QCustomEvent *event );
+
+  private:
+    enum EventType {
+      ConflictEventType = 4044,
+      ChangeEventType,
+      MappingEventType,
+      EngineEventType,
+      MemberEventType
+    };
+
+    class ConflictEvent;
+    class ChangeEvent;
+    class MappingEvent;
+    class EngineEvent;
+    class MemberEvent;
+
+    static void conflict_callback( OSyncEngine*, OSyncMapping*, void* );
+    static void change_callback( OSyncEngine*, OSyncChangeUpdate*, void* );
+    static void mapping_callback( OSyncMappingUpdate*, void* );
+    static void engine_callback( OSyncEngine*, OSyncEngineUpdate*, void* );
+    static void member_callback( OSyncMemberUpdate*, void* );
+
+    Engine* mEngine;
+};
+
+}
+
+#endif
diff --git a/kitchensync/libqopensync/conversion.cpp b/kitchensync/libqopensync/conversion.cpp
new file mode 100644
index 000000000..bf4eb948a
--- /dev/null
+++ b/kitchensync/libqopensync/conversion.cpp
@@ -0,0 +1,58 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2006 Tobias Koenig <tokoe@kde.org>
+
+    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 <opensync/opensync.h>
+
+#include "conversion.h"
+
+using namespace QSync;
+
+Conversion::Conversion()
+  : mEnvironment( 0 )
+{
+}
+
+Conversion::~Conversion()
+{
+}
+
+bool Conversion::isValid() const
+{
+  return mEnvironment != 0;
+}
+
+QStringList Conversion::objectTypes() const
+{
+  Q_ASSERT( mEnvironment );
+
+  OSyncFormatEnv *formatEnv = osync_conv_env_new( mEnvironment );
+  Q_ASSERT( formatEnv );
+
+  QStringList types;	
+  for ( int i = 0; i < osync_conv_num_objtypes( formatEnv ); i++ ) {
+    OSyncObjType *type = osync_conv_nth_objtype( formatEnv, i );
+    types.append( QString::fromUtf8( osync_objtype_get_name( type ) ) );
+  }
+
+  osync_conv_env_free( formatEnv );
+
+  return types;
+}
diff --git a/kitchensync/libqopensync/conversion.h b/kitchensync/libqopensync/conversion.h
new file mode 100644
index 000000000..327f8b475
--- /dev/null
+++ b/kitchensync/libqopensync/conversion.h
@@ -0,0 +1,56 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2006 Tobias Koenig <tokoe@kde.org>
+
+    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 QSYNC_CONVERSION_H
+#define QSYNC_CONVERSION_H
+
+#include <qstringlist.h>
+
+class OSyncEnv;
+
+namespace QSync {
+
+class Conversion
+{
+  friend class Environment;
+
+  public:
+    Conversion();
+    ~Conversion();
+
+    /**
+      Returns whether the object is a valid conversion.
+     */
+    bool isValid() const;
+
+    /**
+      Returns the list of names of supported object types.
+     */
+    QStringList objectTypes() const;
+
+  private:
+    OSyncEnv *mEnvironment;
+};
+
+}
+
+#endif
+
diff --git a/kitchensync/libqopensync/engine.cpp b/kitchensync/libqopensync/engine.cpp
new file mode 100644
index 000000000..6d48c72ff
--- /dev/null
+++ b/kitchensync/libqopensync/engine.cpp
@@ -0,0 +1,67 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 <opensync/opensync.h>
+#include <osengine/engine.h>
+
+#include "engine.h"
+
+using namespace QSync;
+
+Engine::Engine( const Group &group )
+{
+  OSyncError *error = 0;
+  mEngine = osengine_new( group.mGroup, &error );
+}
+
+Engine::~Engine()
+{
+  osengine_free( mEngine );
+  mEngine = 0;
+}
+
+Result Engine::initialize()
+{
+  OSyncError *error = 0;
+  if ( !osengine_init( mEngine, &error ) )
+    return Result( &error );
+  else
+    return Result();
+}
+
+void Engine::finalize()
+{
+  osengine_finalize( mEngine );
+}
+
+Result Engine::synchronize()
+{
+  OSyncError *error = 0;
+  if ( !osengine_synchronize( mEngine, &error ) )
+    return Result( &error );
+  else
+    return Result();
+}
+
+void Engine::abort()
+{
+  osengine_abort( mEngine );
+}
diff --git a/kitchensync/libqopensync/engine.h b/kitchensync/libqopensync/engine.h
new file mode 100644
index 000000000..e62a5f689
--- /dev/null
+++ b/kitchensync/libqopensync/engine.h
@@ -0,0 +1,72 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 QSYNC_ENGINE_H
+#define QSYNC_ENGINE_H
+
+#include <libqopensync/group.h>
+
+class OSyncEngine;
+
+namespace QSync {
+
+class Engine
+{
+  friend class CallbackHandler;
+
+  public:
+    /**
+      Constructs an engine .
+     */
+    Engine( const Group &group );
+
+    /**
+      Destroys the engine.
+     */
+    ~Engine();
+
+    /**
+      Initializes the engine.
+     */
+    Result initialize();
+
+    /**
+      Finalizes the engine.
+     */
+    void finalize();
+
+    /**
+      Starts the synchronization process.
+     */
+    Result synchronize();
+
+    /**
+      Stops the synchronization process.
+     */
+    void abort();
+
+  private:
+    OSyncEngine *mEngine;
+};
+
+}
+
+#endif
diff --git a/kitchensync/libqopensync/environment.cpp b/kitchensync/libqopensync/environment.cpp
new file mode 100644
index 000000000..d878c61d5
--- /dev/null
+++ b/kitchensync/libqopensync/environment.cpp
@@ -0,0 +1,172 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 "environment.h"
+
+#include <opensync/opensync.h>
+
+using namespace QSync;
+
+Environment::Environment()
+{
+  mEnvironment = osync_env_new();
+}
+
+Environment::~Environment()
+{
+  osync_env_free( mEnvironment );
+}
+
+Environment::GroupIterator Environment::groupBegin()
+{
+  GroupIterator it( this );
+  it.mPos = 0;
+
+  return it;
+}
+
+Environment::GroupIterator Environment::groupEnd()
+{
+  GroupIterator it( this );
+  it.mPos = groupCount();
+
+  return it;
+}
+
+Environment::PluginIterator Environment::pluginBegin()
+{
+  PluginIterator it( this );
+  it.mPos = 0;
+
+  return it;
+}
+
+Environment::PluginIterator Environment::pluginEnd()
+{
+  PluginIterator it( this );
+  it.mPos = pluginCount();
+
+  return it;
+}
+
+Result Environment::initialize()
+{
+  OSyncError *error = 0;
+  if ( !osync_env_initialize( mEnvironment, &error ) )
+    return Result( &error );
+  else
+    return Result();
+}
+
+Result Environment::finalize()
+{
+  OSyncError *error = 0;
+  if ( !osync_env_finalize( mEnvironment, &error ) )
+    return Result( &error);
+  else
+    return Result();
+}
+
+int Environment::groupCount() const
+{
+  return osync_env_num_groups( mEnvironment );
+}
+
+Group Environment::groupAt( int pos ) const
+{
+  Group group;
+
+  if ( pos < 0 || pos >= groupCount() )
+    return group;
+
+  OSyncGroup *ogroup = osync_env_nth_group( mEnvironment, pos );
+  group.mGroup = ogroup;
+
+  return group;
+}
+
+Group Environment::groupByName( const QString &name ) const
+{
+  Group group;
+
+  OSyncGroup *ogroup = osync_env_find_group( mEnvironment, name.latin1() );
+  if ( ogroup )
+    group.mGroup = ogroup;
+
+  return group;
+}
+
+Group Environment::addGroup()
+{
+  Group group;
+
+  OSyncGroup *ogroup = osync_group_new( mEnvironment );
+  if ( ogroup )
+    group.mGroup = ogroup;
+
+  return group;
+}
+
+Result Environment::removeGroup( const Group &group )
+{
+  OSyncError *error = 0;
+  if ( !osync_group_delete( group.mGroup, &error ) )
+    return Result( &error );
+  else
+    return Result();
+}
+
+int Environment::pluginCount() const
+{
+  return osync_env_num_plugins( mEnvironment );
+}
+
+Plugin Environment::pluginAt( int pos ) const
+{
+  Plugin plugin;
+
+  if ( pos < 0 || pos >= pluginCount() )
+    return plugin;
+
+  OSyncPlugin *oplugin = osync_env_nth_plugin( mEnvironment, pos );
+  plugin.mPlugin = oplugin;
+
+  return plugin;
+}
+
+Plugin Environment::pluginByName( const QString &name ) const
+{
+  Plugin plugin;
+
+  OSyncPlugin *oplugin = osync_env_find_plugin( mEnvironment, name.latin1() );
+  if ( oplugin )
+    plugin.mPlugin = oplugin;
+
+  return plugin;
+}
+
+Conversion Environment::conversion() const
+{
+  Conversion conversion;
+  conversion.mEnvironment = mEnvironment;
+
+  return conversion;
+}
diff --git a/kitchensync/libqopensync/environment.h b/kitchensync/libqopensync/environment.h
new file mode 100644
index 000000000..f412a32c0
--- /dev/null
+++ b/kitchensync/libqopensync/environment.h
@@ -0,0 +1,199 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 OSYNC_ENVIRONMENT_H
+#define OSYNC_ENVIRONMENT_H
+
+#include <qstring.h>
+
+#include <libqopensync/group.h>
+#include <libqopensync/plugin.h>
+#include <libqopensync/result.h>
+#include <libqopensync/conversion.h>
+
+struct OSyncEnv;
+
+namespace QSync {
+
+class Environment
+{
+  public:
+    Environment();
+    ~Environment();
+
+    class GroupIterator
+    {
+      friend class Environment;
+
+      public:
+        GroupIterator( Environment *environment )
+          : mEnvironment( environment ), mPos( -1 )
+        {
+        }
+
+        GroupIterator( const GroupIterator &it )
+        {
+          mEnvironment = it.mEnvironment;
+          mPos = it.mPos;
+        }
+
+        Group operator*() 
+        {
+          return mEnvironment->groupAt( mPos );
+        }
+
+        GroupIterator &operator++() { mPos++; return *this; }
+        GroupIterator &operator++( int ) { mPos++; return *this; }
+        GroupIterator &operator--() { mPos--; return *this; }
+        GroupIterator &operator--( int ) { mPos--; return *this; }
+        bool operator==( const GroupIterator &it ) { return mEnvironment == it.mEnvironment && mPos == it.mPos; }
+        bool operator!=( const GroupIterator &it ) { return mEnvironment == it.mEnvironment && mPos != it.mPos; }
+
+      private:
+        Environment *mEnvironment;
+        int mPos;
+    };
+
+    class PluginIterator
+    {
+      friend class Environment;
+
+      public:
+        PluginIterator( Environment *environment )
+          : mEnvironment( environment ), mPos( -1 )
+        {
+        }
+
+        PluginIterator( const PluginIterator &it )
+        {
+          mEnvironment = it.mEnvironment;
+          mPos = it.mPos;
+        }
+
+        Plugin operator*() 
+        {
+          return mEnvironment->pluginAt( mPos );
+        }
+
+        PluginIterator &operator++() { mPos++; return *this; }
+        PluginIterator &operator++( int ) { mPos++; return *this; }
+        PluginIterator &operator--() { mPos--; return *this; }
+        PluginIterator &operator--( int ) { mPos--; return *this; }
+        bool operator==( const PluginIterator &it ) { return mEnvironment == it.mEnvironment && mPos == it.mPos; }
+        bool operator!=( const PluginIterator &it ) { return mEnvironment == it.mEnvironment && mPos != it.mPos; }
+
+      private:
+        Environment *mEnvironment;
+        int mPos;
+    };
+
+    /**
+      Returns an iterator pointing to the first item in the group list.
+      This iterator equals groupEnd() if the group list is empty.
+     */
+    GroupIterator groupBegin();
+
+    /**
+      Returns an iterator pointing past the last item in the group list.
+      This iterator equals groupBegin() if the group list is empty.
+     */
+    GroupIterator groupEnd();
+
+    /**
+      Returns an iterator pointing to the first item in the plugin list.
+      This iterator equals pluginEnd() if the group list is empty.
+     */
+    PluginIterator pluginBegin();
+
+    /**
+      Returns an iterator pointing past the last item in the plugin list.
+      This iterator equals pluginBegin() if the plugin list is empty.
+     */
+    PluginIterator pluginEnd();
+
+    /**
+      Initializes the environment ( e.g. loads the groups and plugins ).
+      Has to be called before the groups or plugins can be accessed.
+     */
+    Result initialize();
+
+    /**
+      Finalizes the environment ( e.g. unloads the groups and plugins ).
+      Should be the last call before the object is deleted.
+     */
+    Result finalize();
+
+    /**
+      Returns the number of groups.
+     */
+    int groupCount() const;
+
+    /**
+      Returns the group at position @param pos.
+     */
+    Group groupAt( int pos ) const;
+
+    /**
+      Returns a group by name or an invalid group when the group with this
+      name doesn't exists.
+     */
+    Group groupByName( const QString &name ) const;
+
+    /**
+      Adds a new group to the environment.
+
+      @returns the new group.
+     */
+    Group addGroup();
+
+    /**
+      Removes a group from the environment.
+     */
+    Result removeGroup( const Group &group );
+
+    /**
+      Returns the number of plugins.
+     */
+    int pluginCount() const;
+
+    /**
+      Returns the plugin at position @param pos.
+     */
+    Plugin pluginAt( int pos ) const;
+
+    /**
+      Returns a plugin by name or an invalid plugin when the plugin with this
+      name doesn't exists.
+     */
+    Plugin pluginByName( const QString &name ) const;
+
+    /**
+      Returns the conversion object of this environment.
+     */
+    Conversion conversion() const;
+
+  private:
+    OSyncEnv *mEnvironment;
+};
+
+}
+
+#endif
diff --git a/kitchensync/libqopensync/filter.cpp b/kitchensync/libqopensync/filter.cpp
new file mode 100644
index 000000000..fdfcf032f
--- /dev/null
+++ b/kitchensync/libqopensync/filter.cpp
@@ -0,0 +1,55 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 <opensync/opensync.h>
+
+#include "filter.h"
+
+using namespace QSync;
+
+Filter::Filter()
+  : mFilter( 0 )
+{
+}
+
+Filter::~Filter()
+{
+}
+
+bool Filter::isValid() const
+{
+  return (mFilter != 0);
+}
+
+void Filter::setConfiguration( const QString &configuration )
+{
+  Q_ASSERT( mFilter );
+
+  osync_filter_set_config( mFilter, (const char*)configuration.utf8() );
+}
+
+QString Filter::configuration() const
+{
+  Q_ASSERT( mFilter );
+
+  return QString::fromUtf8( osync_filter_get_config( mFilter ) );
+}
+
diff --git a/kitchensync/libqopensync/filter.h b/kitchensync/libqopensync/filter.h
new file mode 100644
index 000000000..55e3099e1
--- /dev/null
+++ b/kitchensync/libqopensync/filter.h
@@ -0,0 +1,64 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 QSYNC_FILTER_H
+#define QSYNC_FILTER_H
+
+#include <qstring.h>
+
+class OSyncFilter;
+
+namespace QSync {
+
+class Filter
+{
+  friend class Group;
+
+  public:
+    Filter();
+    ~Filter();
+
+    /**
+      Returns whether the object is a valid filter.
+     */
+    bool isValid() const;
+
+    /**
+      Sets the configuration string of this filter. The format of
+      string is filter specific.
+     */
+    void setConfiguration( const QString &configuration );
+
+    /**
+      Returns the configuration string of this filter.
+     */
+    QString configuration() const;
+
+    bool operator==( const Filter &filter ) const { return mFilter == filter.mFilter; }
+
+  private:
+    OSyncFilter *mFilter;
+};
+
+}
+
+#endif
+
diff --git a/kitchensync/libqopensync/group.cpp b/kitchensync/libqopensync/group.cpp
new file mode 100644
index 000000000..75beab90c
--- /dev/null
+++ b/kitchensync/libqopensync/group.cpp
@@ -0,0 +1,292 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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.
+*/
+
+/** hack includes **/
+#include <qdom.h>
+#include <qfile.h>
+/** hack includes **/
+
+#include <opensync/opensync.h>
+
+#include "conversion.h"
+#include "group.h"
+
+using namespace QSync;
+
+/**
+  This class is a quick hack for OpenSync 0.19 and 0.20 because
+  the engine doesn't stores the filter settings itself when calling
+  osync_group_set_objtype_enabled(), so we have to store it for every
+  group in a separated config file. This class encapsulates it.
+ */
+GroupConfig::GroupConfig()
+  : mGroup( 0 )
+{
+}
+
+QStringList GroupConfig::activeObjectTypes() const
+{
+  Q_ASSERT( mGroup );
+
+  const QString fileName = QString( "%1/filter.conf" ).arg( osync_group_get_configdir( mGroup ) );
+
+  QFile file( fileName );
+  if ( !file.open( IO_ReadOnly ) )
+    return QStringList();
+
+  QDomDocument document;
+
+  QString message;
+  if ( !document.setContent( &file, &message ) ) {
+    qDebug( "Error on loading %s: %s", fileName.latin1(), message.latin1() );
+    return QStringList();
+  }
+  file.close();
+
+  QStringList objectTypes;
+
+  QDomElement element = document.documentElement();
+  QDomNode node = element.firstChild();
+  while ( !node.isNull() ) {
+    QDomElement childElement = node.toElement();
+    if ( !childElement.isNull() )
+      objectTypes.append( childElement.tagName() );
+
+    node = node.nextSibling();
+  }
+
+  return objectTypes;
+}
+
+void GroupConfig::setActiveObjectTypes( const QStringList &objectTypes )
+{
+  Q_ASSERT( mGroup );
+
+  QDomDocument document( "Filter" );
+  document.appendChild( document.createProcessingInstruction(
+                        "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
+
+  QDomElement element = document.createElement( "filter" );
+  document.appendChild( element );
+
+  for ( uint i = 0; i < objectTypes.count(); ++i ) {
+    QDomElement entry = document.createElement( objectTypes[ i ] );
+    element.appendChild( entry );
+  }
+
+  const QString fileName = QString( "%1/filter.conf" ).arg( osync_group_get_configdir( mGroup ) );
+
+  QFile file( fileName );
+  if ( !file.open( IO_WriteOnly ) )
+    return;
+
+  QTextStream s( &file );
+  s.setEncoding( QTextStream::UnicodeUTF8 );
+  s << document.toString();
+  file.close();
+}
+
+
+Group::Group()
+  : mGroup( 0 )
+{
+}
+
+Group::~Group()
+{
+}
+
+bool Group::isValid() const
+{
+  return ( mGroup != 0 );
+}
+
+Group::Iterator Group::begin()
+{
+  Iterator it( this );
+  it.mPos = 0;
+
+  return it;
+}
+
+Group::Iterator Group::end()
+{
+  Iterator it( this );
+  it.mPos = memberCount();
+
+  return it;
+}
+
+void Group::setName( const QString &name )
+{
+  Q_ASSERT( mGroup );
+
+  osync_group_set_name( mGroup, name.latin1() );
+}
+
+QString Group::name() const
+{
+  Q_ASSERT( mGroup );
+
+  return QString::fromLatin1( osync_group_get_name( mGroup ) );
+}
+
+void Group::setLastSynchronization( const QDateTime &dateTime )
+{
+  Q_ASSERT( mGroup );
+
+  if ( dateTime.isValid() )
+    osync_group_set_last_synchronization( mGroup, dateTime.toTime_t() );
+}
+
+QDateTime Group::lastSynchronization() const
+{
+  Q_ASSERT( mGroup );
+
+  QDateTime dateTime;
+  time_t time = osync_group_get_last_synchronization( mGroup );
+  if ( time != 0 )
+    dateTime.setTime_t( time );
+
+  return dateTime;
+}
+
+Group::LockType Group::lock()
+{
+  Q_ASSERT( mGroup );
+
+  OSyncLockState state = osync_group_lock( mGroup );
+  switch ( state ) {
+    default:
+    case OSYNC_LOCK_OK:
+      return LockOk;
+      break;
+    case OSYNC_LOCKED:
+      return Locked;
+      break;
+    case OSYNC_LOCK_STALE:
+      return LockStale;
+      break;
+  }
+}
+
+void Group::unlock( bool removeFile )
+{
+  Q_ASSERT( mGroup );
+
+  osync_group_unlock( mGroup, removeFile );
+}
+
+Member Group::addMember()
+{
+  Q_ASSERT( mGroup );
+
+  OSyncMember *omember = osync_member_new( mGroup );
+
+  Member member;
+  member.mMember = omember;
+
+  save();
+
+  return member;
+}
+
+void Group::removeMember( const Member &member )
+{
+  Q_ASSERT( mGroup );
+
+  osync_group_remove_member( mGroup, member.mMember );
+}
+
+int Group::memberCount() const
+{
+  Q_ASSERT( mGroup );
+
+  return osync_group_num_members( mGroup );
+}
+
+Member Group::memberAt( int pos ) const
+{
+  Q_ASSERT( mGroup );
+
+  Member member;
+
+  if ( pos < 0 || pos >= memberCount() )
+    return member;
+
+  member.mMember = osync_group_nth_member( mGroup, pos );
+
+  return member;
+}
+
+int Group::filterCount() const
+{
+  Q_ASSERT( mGroup );
+
+  return osync_group_num_filters( mGroup );
+}
+
+Filter Group::filterAt( int pos )
+{
+  Q_ASSERT( mGroup );
+
+  Filter filter;
+
+  if ( pos < 0 || pos >= filterCount() )
+    return filter;
+
+  filter.mFilter = osync_group_nth_filter( mGroup, pos );
+
+  return filter;
+}
+
+Result Group::save()
+{
+  Q_ASSERT( mGroup );
+
+  OSyncError *error = 0;
+  if ( !osync_group_save( mGroup, &error ) )
+    return Result( &error );
+  else
+    return Result();
+}
+
+void Group::setObjectTypeEnabled( const QString &objectType, bool enabled )
+{
+  Q_ASSERT( mGroup );
+
+  osync_group_set_objtype_enabled( mGroup, objectType.utf8(), enabled );
+}
+
+bool Group::isObjectTypeEnabled( const QString &objectType ) const
+{
+  return osync_group_objtype_enabled( mGroup, objectType.utf8() );
+}
+
+GroupConfig Group::config() const
+{
+  Q_ASSERT( mGroup );
+
+  GroupConfig config;
+  config.mGroup = mGroup;
+
+  return config;
+}
diff --git a/kitchensync/libqopensync/group.h b/kitchensync/libqopensync/group.h
new file mode 100644
index 000000000..e03365dfe
--- /dev/null
+++ b/kitchensync/libqopensync/group.h
@@ -0,0 +1,217 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 QSYNC_GROUP_H
+#define QSYNC_GROUP_H
+
+#include <qdatetime.h>
+#include <qstringlist.h>
+
+#include <libqopensync/filter.h>
+#include <libqopensync/member.h>
+
+class OSyncGroup;
+
+namespace QSync {
+
+/**
+  @internal
+ */
+class GroupConfig
+{
+  friend class Group;
+
+  public:
+    GroupConfig();
+
+    QStringList activeObjectTypes() const;
+    void setActiveObjectTypes( const QStringList &objectTypes );
+
+  private:
+    OSyncGroup *mGroup;
+};
+
+
+class Group
+{
+  friend class Engine;
+  friend class Environment;
+
+  public:
+    enum LockType
+    {
+      LockOk,
+      Locked,
+      LockStale
+    };
+
+    Group();
+    ~Group();
+
+    /**
+      Returns whether the object is a valid group.
+     */
+    bool isValid() const;
+
+    class Iterator
+    {
+      friend class Group;
+
+      public:
+        Iterator( Group *group )
+          : mGroup( group ), mPos( -1 )
+        {
+        }
+
+        Iterator( const Iterator &it )
+        {
+          mGroup = it.mGroup;
+          mPos = it.mPos;
+        }
+
+        Member operator*() 
+        {
+          return mGroup->memberAt( mPos );
+        }
+
+        Iterator &operator++() { mPos++; return *this; }
+        Iterator &operator++( int ) { mPos++; return *this; }
+        Iterator &operator--() { mPos--; return *this; }
+        Iterator &operator--( int ) { mPos--; return *this; }
+        bool operator==( const Iterator &it ) { return mGroup == it.mGroup && mPos == it.mPos; }
+        bool operator!=( const Iterator &it ) { return mGroup == it.mGroup && mPos != it.mPos; }
+
+      private:
+        Group *mGroup;
+        int mPos;
+    };
+
+    /**
+      Returns an iterator pointing to the first item in the member list.
+      This iterator equals end() if the member list is empty.
+     */
+    Iterator begin();
+
+    /**
+      Returns an iterator pointing past the last item in the member list.
+      This iterator equals begin() if the member list is empty.
+     */
+    Iterator end();
+
+    /**
+      Sets the name of the group.
+     */
+    void setName( const QString &name );
+
+    /**
+      Returns the name of the group.
+     */
+    QString name() const;
+
+    /**
+      Sets the time of the last successfull synchronization.
+     */
+    void setLastSynchronization( const QDateTime &dateTime );
+
+    /**
+      Returns the time of the last successfull synchronization.
+     */
+    QDateTime lastSynchronization() const;
+
+    /**
+      Locks the group.
+
+      @returns The the result of the locking request.
+     */
+    LockType lock();
+
+    /**
+      Unlocks the group.
+
+      @param removeFile Whether the lock file shall be removed.
+     */
+    void unlock( bool removeFile = true );
+
+    /**
+      Adds a new member to the group.
+
+      @returns the new member.
+     */
+    Member addMember();
+
+    /**
+      Removes a member from the group.
+     */
+    void removeMember( const Member &member );
+
+    /**
+      Returns the number of members.
+     */
+    int memberCount() const;
+
+    /**
+      Returns the member at position @param pos.
+     */
+    Member memberAt( int pos ) const;
+
+    /**
+      Returns the number of filters.
+     */
+    int filterCount() const;
+
+    /**
+      Returns the filter at position @param pos.
+     */
+    Filter filterAt( int pos );
+
+    /**
+      Set, if the object type with given name is enabled for synchronisation for
+      this group.
+     */
+    void setObjectTypeEnabled( const QString &objectType, bool enabled );
+
+    /**
+      Returns whether the object type with given name is enabled for synchronisation for
+      this group.
+     */
+    bool isObjectTypeEnabled( const QString &objectType ) const;
+
+    /**
+      Saves the configuration to hard disc.
+     */
+    Result save();
+
+    /**
+      Returns the config object of this group.
+
+      Note: This method is only available for OpenSync 0.19 and 0.20.
+     */
+    GroupConfig config() const;
+
+    bool operator==( const Group &group ) const { return mGroup == group.mGroup; }
+
+  private:
+    OSyncGroup *mGroup;
+};
+
+}
+
+#endif
diff --git a/kitchensync/libqopensync/member.cpp b/kitchensync/libqopensync/member.cpp
new file mode 100644
index 000000000..3ac24f0dc
--- /dev/null
+++ b/kitchensync/libqopensync/member.cpp
@@ -0,0 +1,188 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 <opensync/opensync.h>
+#include <stdlib.h>
+
+#include "member.h"
+
+using namespace QSync;
+
+Member::Member()
+  : mMember( 0 )
+{
+}
+
+Member::~Member()
+{
+}
+
+bool Member::isValid() const
+{
+  OSyncError *error = 0;
+
+  if ( !mMember )
+    return false;
+
+  if ( !osync_member_instance_plugin( mMember, pluginName().utf8(), &error ) ) {
+    qDebug( "Plugin %s is not valid: %s", pluginName().latin1(), osync_error_print( &error ) );
+    osync_error_free( &error );
+    return false;
+  }
+
+  return true;
+}
+
+QString Member::configurationDirectory() const
+{
+  Q_ASSERT( mMember );
+
+  return QString::fromLatin1( osync_member_get_configdir( mMember ) );
+}
+
+QString Member::pluginName() const
+{
+  Q_ASSERT( mMember );
+
+  return QString::fromLatin1( osync_member_get_pluginname( mMember ) );
+}
+
+Plugin Member::plugin() const
+{
+  Q_ASSERT( mMember );
+
+  Plugin plugin;
+
+  OSyncPlugin *oplugin = osync_member_get_plugin( mMember );
+  if ( oplugin )
+    plugin.mPlugin = oplugin;
+
+  return plugin;
+}
+
+int Member::id() const
+{
+  Q_ASSERT( mMember );
+
+  return osync_member_get_id( mMember );
+}
+
+void Member::setName( const QString &name )
+{
+  Q_ASSERT( mMember );
+
+  osync_member_set_name( mMember, (const char*)name.utf8() );
+}
+
+QString Member::name() const
+{
+  Q_ASSERT( mMember );
+
+  return QString::fromUtf8( osync_member_get_name( mMember ) );
+}
+
+void Member::setConfiguration( const QByteArray &configurationData )
+{
+  Q_ASSERT( mMember );
+
+  osync_member_set_config( mMember, configurationData.data(), configurationData.size() );
+}
+
+Result Member::configuration( QByteArray &configurationData, bool useDefault )
+{
+  Q_ASSERT( mMember );
+
+  char *data;
+  int size;
+
+  OSyncError *error = 0;
+  osync_bool ok = false;
+  if ( useDefault )
+    ok = osync_member_get_config_or_default( mMember, &data, &size, &error );
+  else
+    ok = osync_member_get_config( mMember, &data, &size, &error );
+
+  if ( !ok ) {
+    return Result( &error );
+  } else {
+    configurationData.resize( size );
+    memcpy( configurationData.data(), data, size );
+
+    return Result();
+  }
+}
+
+Result Member::save()
+{
+  Q_ASSERT( mMember );
+
+  OSyncError *error = 0;
+  if ( !osync_member_save( mMember, &error ) )
+    return Result( &error );
+  else
+    return Result();
+}
+
+Result Member::instance( const Plugin &plugin )
+{
+  OSyncError *error = 0;
+  if ( !osync_member_instance_plugin( mMember, plugin.name().utf8(), &error ) )
+    return Result( &error );
+  else
+    return Result();
+}
+
+bool Member::operator==( const Member &member ) const
+{
+  return mMember == member.mMember;
+}
+
+QString Member::scanDevices( const QString &query )
+{
+  Q_ASSERT( mMember );
+
+  OSyncError *error = 0;
+  char *data = (char*)osync_member_call_plugin( mMember, "scan_devices", const_cast<char*>( query.utf8().data() ), &error );
+  if ( error != 0 ) {
+    osync_error_free( &error );
+    return QString();
+  } else {
+    QString xml = QString::fromUtf8( data );
+    free( data );
+    return xml;
+  }
+}
+
+bool Member::testConnection( const QString &configuration )
+{
+  Q_ASSERT( mMember );
+
+  OSyncError *error = 0;
+  int *result = (int*)osync_member_call_plugin( mMember, "test_connection", const_cast<char*>( configuration.utf8().data() ), &error );
+  if ( error != 0 ) {
+    osync_error_free( &error );
+    return false;
+  } else {
+    bool value = ( *result == 1 ? true : false );
+    free( result );
+    return value;
+  }
+}
diff --git a/kitchensync/libqopensync/member.h b/kitchensync/libqopensync/member.h
new file mode 100644
index 000000000..d0d883db3
--- /dev/null
+++ b/kitchensync/libqopensync/member.h
@@ -0,0 +1,129 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 QSYNC_MEMBER_H
+#define QSYNC_MEMBER_H
+
+#include <libqopensync/plugin.h>
+#include <libqopensync/result.h>
+#include <libqopensync/plugin.h>
+
+class OSyncMember;
+
+namespace QSync {
+
+class Member
+{
+  friend class Group;
+  friend class SyncChange;
+  friend class SyncMemberUpdate;
+
+  public:
+    Member();
+    ~Member();
+
+    /**
+      Returns whether the member object is valid.
+     */
+    bool isValid() const;
+
+    /**
+      Returns the configuration directory.
+     */
+    QString configurationDirectory() const;
+
+    /**
+      Returns the name of the plugin, the member belongs to.
+     */
+    QString pluginName() const;
+
+    /**
+      Returns the plugin, the member belongs to.
+     */
+    Plugin plugin() const;
+
+    /**
+      Returns the id of the plugin.
+    */
+    int id() const;
+
+    /**
+      Sets the name of this member.
+     */
+    void setName( const QString &name );
+
+    /**
+      Returns the name of this member.
+     */
+    QString name() const;
+
+    /**
+      Sets the configuration data as byte array. The developer has to decide the
+      type of the data ( e.g. xml, plain text, binary ).
+     */
+    void setConfiguration( const QByteArray &configurationData );
+
+    /**
+      Gets the configuration data as byte array. The developer has to decide the
+      type of the data ( e.g. xml, plain text, binary ).
+
+      @param useDefault  If set to true, return default config, if no config
+                         exists. If set to false, return error when no config
+                         exists.
+
+      @returns The result of this operation.
+     */
+    Result configuration( QByteArray &configurationData,
+      bool useDefault = true );
+
+    /**
+      Saves the changes to the configuration to hard disc.
+     */
+    Result save();
+
+    /**
+      Make this member an instance of the given plugin.
+    */
+    Result instance( const Plugin & );
+
+    bool operator==( const Member& ) const;
+
+    /**
+      This method can be used to query the plugin for scanning devices.
+      The @param query is a plugin specific xml document as well as
+      the return value.
+     */
+    QString scanDevices( const QString &query );
+
+    /**
+      This method can be used to test whether the plugin can connect
+      to the device with the given configuration.
+     */
+    bool testConnection( const QString &configuration );
+
+  private:
+    OSyncMember *mMember;
+};
+
+}
+
+#endif
+
diff --git a/kitchensync/libqopensync/plugin.cpp b/kitchensync/libqopensync/plugin.cpp
new file mode 100644
index 000000000..d22a5f344
--- /dev/null
+++ b/kitchensync/libqopensync/plugin.cpp
@@ -0,0 +1,62 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 <opensync/opensync.h>
+
+#include "plugin.h"
+
+using namespace QSync;
+
+Plugin::Plugin()
+  : mPlugin( 0 )
+{
+}
+
+Plugin::~Plugin()
+{
+}
+
+bool Plugin::isValid() const
+{
+  return ( mPlugin != 0 );
+}
+
+QString Plugin::name() const
+{
+  Q_ASSERT( mPlugin );
+
+  return QString::fromLatin1( osync_plugin_get_name( mPlugin ) );
+}
+
+QString Plugin::longName() const
+{
+  Q_ASSERT( mPlugin );
+
+  return QString::fromLatin1( osync_plugin_get_longname( mPlugin ) );
+}
+
+QString Plugin::description() const
+{
+  Q_ASSERT( mPlugin );
+
+  return QString::fromLatin1( osync_plugin_get_description( mPlugin ) );
+}
+
diff --git a/kitchensync/libqopensync/plugin.h b/kitchensync/libqopensync/plugin.h
new file mode 100644
index 000000000..e951dfffa
--- /dev/null
+++ b/kitchensync/libqopensync/plugin.h
@@ -0,0 +1,67 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 QSYNC_PLUGIN_H
+#define QSYNC_PLUGIN_H
+
+#include <qstring.h>
+
+class OSyncPlugin;
+
+namespace QSync {
+
+class Plugin
+{
+  friend class Environment;
+  friend class Member;
+
+  public:
+    Plugin();
+    ~Plugin();
+
+    /**
+      Returns whether the object is a valid plugin.
+     */
+    bool isValid() const;
+
+    /**
+      Returns the name of the plugin.
+     */
+    QString name() const;
+
+    /**
+      Returns the long name of the plugin.
+     */
+    QString longName() const;
+
+    /**
+      Returns the description of the plugin.
+     */
+    QString description() const;
+
+  private:
+    OSyncPlugin *mPlugin;
+};
+
+}
+
+#endif
+
diff --git a/kitchensync/libqopensync/result.cpp b/kitchensync/libqopensync/result.cpp
new file mode 100644
index 000000000..b46040418
--- /dev/null
+++ b/kitchensync/libqopensync/result.cpp
@@ -0,0 +1,149 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 "result.h"
+
+#include <opensync/opensync.h>
+
+using namespace QSync;
+
+Result::Result()
+  : mType( NoError )
+{
+}
+
+Result::Result( Type type )
+  : mType( type )
+{
+}
+
+Result::Result( OSyncError **error, bool deleteError )
+{
+  OSyncErrorType otype = osync_error_get_type( error );
+  Type type;
+
+  switch ( otype ) {
+    case OSYNC_NO_ERROR:
+      type = NoError;
+      break;
+    default:
+    case OSYNC_ERROR_GENERIC:
+      type = GenericError;
+      break;
+    case OSYNC_ERROR_IO_ERROR:
+      type = IOError;
+      break;
+    case OSYNC_ERROR_NOT_SUPPORTED:
+      type = NotSupported;
+      break;
+    case OSYNC_ERROR_TIMEOUT:
+      type = Timeout;
+      break;
+    case OSYNC_ERROR_DISCONNECTED:
+      type = Disconnected;
+      break;
+    case OSYNC_ERROR_FILE_NOT_FOUND:
+      type = FileNotFound;
+      break;
+    case OSYNC_ERROR_EXISTS:
+      type = Exists;
+      break;
+    case OSYNC_ERROR_CONVERT:
+      type = Convert;
+      break;
+    case OSYNC_ERROR_MISCONFIGURATION:
+      type = Misconfiguration;
+      break;
+    case OSYNC_ERROR_INITIALIZATION:
+      type = Initialization;
+      break;
+    case OSYNC_ERROR_PARAMETER:
+      type = Parameter;
+      break;
+    case OSYNC_ERROR_EXPECTED:
+      type = Expected;
+      break;
+    case OSYNC_ERROR_NO_CONNECTION:
+      type = NoConnection;
+      break;
+    case OSYNC_ERROR_TEMPORARY:
+      type = Temporary;
+      break;
+    case OSYNC_ERROR_LOCKED:
+      type = Locked;
+      break;
+    case OSYNC_ERROR_PLUGIN_NOT_FOUND:
+      type = PluginNotFound;
+      break;
+  }
+
+  mType = type;
+  mName = QString::fromUtf8( osync_error_get_name( error ) );
+  mMessage = QString::fromUtf8( osync_error_print( error ) );
+
+  if ( deleteError )
+    osync_error_free( error );
+}
+
+Result::~Result()
+{
+}
+
+void Result::setName( const QString &name )
+{
+  mName = name;
+}
+
+QString Result::name() const
+{
+  return mName;
+}
+
+void Result::setMessage( const QString &message )
+{
+  mMessage = message;
+}
+
+QString Result::message() const
+{
+  return mMessage;
+}
+
+void Result::setType( Type type )
+{
+  mType = type;
+}
+
+Result::Type Result::type() const
+{
+  return mType;
+}
+
+bool Result::isError() const
+{
+  return mType != NoError;
+}
+
+Result::operator bool () const
+{
+  return ( mType != NoError );
+}
+
diff --git a/kitchensync/libqopensync/result.h b/kitchensync/libqopensync/result.h
new file mode 100644
index 000000000..c7cf13d70
--- /dev/null
+++ b/kitchensync/libqopensync/result.h
@@ -0,0 +1,126 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 QSYNC_RESULT_H
+#define QSYNC_RESULT_H
+
+#include <qstring.h>
+
+struct OSyncError;
+
+namespace QSync {
+
+class Result
+{
+  public:
+    /**
+      Result types.
+     */
+    enum Type {
+      NoError,
+      GenericError,
+      IOError,
+      NotSupported,
+      Timeout,
+      Disconnected,
+      FileNotFound,
+      Exists,
+      Convert,
+      Misconfiguration,
+      Initialization,
+      Parameter,
+      Expected,
+      NoConnection,
+      Temporary,
+      Locked,
+      PluginNotFound
+    };
+
+    /**
+      Constructs a NoError result.
+     */
+    Result();
+
+    /**
+      Constructs a result of the given type.
+     */
+    Result( Type type );
+
+    /**
+      Construct Result from OpenSync error object. Deletes the OpenSync error
+      object.
+    */
+    Result( OSyncError **, bool deleteError = true );
+
+    /**
+      Destroys the result.
+     */
+    ~Result();
+
+    /**
+      Sets the name of the result.
+     */
+    void setName( const QString &name );
+
+    /**
+      Returns the name of the result.
+     */
+    QString name() const;
+
+    /**
+      Sets the message text of the result.
+     */
+    void setMessage( const QString &message );
+
+    /**
+      Returns the message text of the result.
+     */
+    QString message() const;
+
+    /**
+      Sets the type of the result.
+     */
+    void setType( Type type );
+
+    /**
+      Returns the type of the result.
+     */
+    Type type() const;
+
+    /**
+      Reimplemented boolean operator.
+     */
+    operator bool () const;
+
+    /**
+      Return true, if this Result is an error, return false otherwise.
+    */
+    bool isError() const;
+
+  private:
+    QString mName;
+    QString mMessage;
+    Type mType;
+};
+
+}
+
+#endif
diff --git a/kitchensync/libqopensync/syncchange.cpp b/kitchensync/libqopensync/syncchange.cpp
new file mode 100644
index 000000000..f64ef6493
--- /dev/null
+++ b/kitchensync/libqopensync/syncchange.cpp
@@ -0,0 +1,159 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 <opensync/file.h>
+#include <opensync/opensync.h>
+
+#include "syncchange.h"
+
+using namespace QSync;
+
+SyncChange::SyncChange()
+{
+}
+
+SyncChange::SyncChange( OSyncChange *change )
+{
+  mSyncChange = change;
+}
+
+SyncChange::~SyncChange()
+{
+}
+
+bool SyncChange::isValid() const
+{
+  return ( mSyncChange != 0 );
+}
+
+void SyncChange::setUid( const QString &uid )
+{
+  osync_change_set_uid( mSyncChange, uid.utf8() );
+}
+
+QString SyncChange::uid() const
+{
+  return QString::fromUtf8( osync_change_get_uid( mSyncChange ) );
+}
+
+void SyncChange::setHash( const QString &hash )
+{
+  osync_change_set_hash( mSyncChange, hash.utf8() );
+}
+
+QString SyncChange::hash() const
+{
+  return QString::fromUtf8( osync_change_get_hash( mSyncChange ) );
+}
+
+void SyncChange::setData( const QString &data )
+{
+  osync_change_set_data( mSyncChange, const_cast<char*>( data.utf8().data() ), data.utf8().size(), true );
+}
+
+QString SyncChange::data() const
+{
+  int size = osync_change_get_datasize( mSyncChange );
+
+  QString content;
+  if ( objectFormatName() == "file" ) {
+    fileFormat *format = (fileFormat*)osync_change_get_data( mSyncChange );
+    if ( format )
+      content = QString::fromUtf8( format->data, format->size );
+  } else
+    content = QString::fromUtf8( osync_change_get_data( mSyncChange ), size );
+
+  return content;
+}
+
+bool SyncChange::hasData() const
+{
+  return osync_change_has_data( mSyncChange );
+}
+
+QString SyncChange::objectFormatName() const
+{
+  OSyncObjFormat *format = osync_change_get_objformat( mSyncChange );
+  Q_ASSERT( format );
+
+  return QString::fromUtf8( osync_objformat_get_name( format ) );
+}
+
+Member SyncChange::member() const
+{
+  OSyncMember *omember = osync_change_get_member( mSyncChange );
+
+  Member m;
+  m.mMember = omember;
+
+  return m;
+}
+
+void SyncChange::setChangeType( Type changeType )
+{
+  OSyncChangeType ochangeType;
+
+  switch ( changeType ) {
+    case AddedChange:
+      ochangeType = CHANGE_ADDED;
+      break;
+    case UnmodifiedChange:
+      ochangeType = CHANGE_UNMODIFIED;
+      break;
+    case DeletedChange:
+      ochangeType = CHANGE_DELETED;
+      break;
+    case ModifiedChange:
+      ochangeType = CHANGE_MODIFIED;
+      break;
+    case UnknownChange:
+    default:
+      ochangeType = CHANGE_UNKNOWN;
+      break;
+  }
+
+  osync_change_set_changetype( mSyncChange, ochangeType );
+}
+
+SyncChange::Type SyncChange::changeType() const
+{
+  OSyncChangeType ochangeType = osync_change_get_changetype( mSyncChange );
+
+  switch ( ochangeType ) {
+    case CHANGE_ADDED:
+      return AddedChange;
+      break;
+    case CHANGE_UNMODIFIED:
+      return UnmodifiedChange;
+      break;
+    case CHANGE_DELETED:
+      return DeletedChange;
+      break;
+    case CHANGE_MODIFIED:
+      return ModifiedChange;
+      break;
+    case CHANGE_UNKNOWN:
+    default:
+      return UnknownChange;
+      break;
+  }
+}
+
diff --git a/kitchensync/libqopensync/syncchange.h b/kitchensync/libqopensync/syncchange.h
new file mode 100644
index 000000000..775d3a8ed
--- /dev/null
+++ b/kitchensync/libqopensync/syncchange.h
@@ -0,0 +1,116 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 QSYNC_SYNCCHANGE_H
+#define QSYNC_SYNCCHANGE_H
+
+#include <libqopensync/member.h>
+
+class OSyncChange;
+
+namespace QSync {
+
+class SyncChange
+{
+  friend class SyncMapping;
+
+  public:
+    enum Type
+    {
+      UnknownChange,
+      AddedChange,
+      UnmodifiedChange,
+      DeletedChange,
+      ModifiedChange
+    };
+
+    SyncChange();
+    SyncChange( OSyncChange* );
+    ~SyncChange();
+
+    /**
+      Returns whether it's a valid SyncChange.
+     */
+    bool isValid() const;
+
+    /**
+      Sets the uid of this change.
+     */
+    void setUid( const QString &uid );
+
+    /**
+      Returns the uid of this change.
+     */
+    QString uid() const;
+
+    /**
+      Sets the hash of this change.
+     */
+    void setHash( const QString &hash );
+
+    /**
+      Returns the hash of this change.
+     */
+    QString hash() const;
+
+    /**
+      Sets the data provided by the plugin.
+     */
+    void setData( const QString &data );
+
+    /**
+      Returns the data provided by the plugin.
+     */
+    QString data() const;
+
+    /**
+      Returns whether the change contains data.
+     */
+    bool hasData() const;
+
+    /**
+      Returns the object format name.
+     */
+    QString objectFormatName() const;
+
+    /**
+      Returns the parent member of this change.
+     */
+    Member member() const;
+
+    /**
+      Sets the change type.
+     */
+    void setChangeType( Type changeType );
+
+    /**
+      Returns the change type.
+     */
+    Type changeType() const;
+
+  private:
+    OSyncChange *mSyncChange;
+};
+
+}
+
+#endif
+
diff --git a/kitchensync/libqopensync/syncmapping.cpp b/kitchensync/libqopensync/syncmapping.cpp
new file mode 100644
index 000000000..8097c5482
--- /dev/null
+++ b/kitchensync/libqopensync/syncmapping.cpp
@@ -0,0 +1,100 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 <qstring.h>
+#include <osengine/engine.h>
+
+#include "syncmapping.h"
+
+using namespace QSync;
+
+SyncMapping::SyncMapping()
+  : mEngine( 0 ), mMapping( 0 )
+{
+}
+
+SyncMapping::SyncMapping( OSyncMapping *mapping, OSyncEngine *engine )
+  : mEngine( engine ), mMapping( mapping )
+{
+}
+
+SyncMapping::~SyncMapping()
+{
+}
+
+bool SyncMapping::isValid() const
+{
+  return ( mEngine != 0 && mMapping != 0 );
+}
+
+long long SyncMapping::id() const
+{
+  Q_ASSERT( mMapping );
+
+  return osengine_mapping_get_id( mMapping );
+}
+
+void SyncMapping::duplicate()
+{
+  Q_ASSERT( mEngine );
+  Q_ASSERT( mMapping );
+
+  osengine_mapping_duplicate( mEngine, mMapping );
+}
+
+void SyncMapping::solve( const SyncChange &change )
+{
+  Q_ASSERT( mEngine );
+  Q_ASSERT( mMapping );
+  Q_ASSERT( change.isValid() );
+
+  osengine_mapping_solve( mEngine, mMapping, change.mSyncChange );
+}
+
+void SyncMapping::ignore()
+{
+  Q_ASSERT( mEngine );
+  Q_ASSERT( mMapping );
+
+  //TODO: error should be returned as Result
+  OSyncError *error = 0;
+  osengine_mapping_ignore_conflict( mEngine, mMapping, &error );
+}
+
+int SyncMapping::changesCount() const
+{
+  Q_ASSERT( mMapping );
+
+  return osengine_mapping_num_changes( mMapping );
+}
+
+SyncChange SyncMapping::changeAt( int pos )
+{
+  Q_ASSERT( mMapping );
+
+  if ( pos < 0 || pos >= osengine_mapping_num_changes( mMapping ) )
+    return SyncChange();
+
+  OSyncChange *ochange = osengine_mapping_nth_change( mMapping, pos );
+
+  return SyncChange( ochange );
+}
+
diff --git a/kitchensync/libqopensync/syncmapping.h b/kitchensync/libqopensync/syncmapping.h
new file mode 100644
index 000000000..6de67330a
--- /dev/null
+++ b/kitchensync/libqopensync/syncmapping.h
@@ -0,0 +1,59 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 QSYNC_SYNCMAPPING_H
+#define QSYNC_SYNCMAPPING_H
+
+#include <libqopensync/syncchange.h>
+
+class OSyncEngine;
+class OSyncMapping;
+
+namespace QSync {
+
+class SyncMapping
+{
+  friend class SyncMappingUpdate;
+
+  public:
+    SyncMapping();
+    SyncMapping( OSyncMapping*, OSyncEngine* );
+    ~SyncMapping();
+
+    bool isValid() const;
+
+    long long id() const;
+
+    void duplicate();
+    void solve( const SyncChange &change );
+    void ignore();
+
+    int changesCount() const;
+    SyncChange changeAt( int pos );
+
+  private:
+    OSyncEngine *mEngine;
+    OSyncMapping *mMapping;
+};
+
+}
+
+#endif
diff --git a/kitchensync/libqopensync/syncupdates.cpp b/kitchensync/libqopensync/syncupdates.cpp
new file mode 100644
index 000000000..653ccf7f3
--- /dev/null
+++ b/kitchensync/libqopensync/syncupdates.cpp
@@ -0,0 +1,251 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 <osengine/engine.h>
+
+#include "syncupdates.h"
+
+using namespace QSync;
+
+SyncMemberUpdate::SyncMemberUpdate()
+{
+}
+
+SyncMemberUpdate::SyncMemberUpdate( OSyncMemberUpdate *update )
+{
+  switch ( update->type ) {
+    case MEMBER_CONNECTED:
+      mType = Connected;
+      break;
+    case MEMBER_SENT_CHANGES:
+      mType = SentChanges;
+      break;
+    case MEMBER_COMMITTED_ALL:
+      mType = CommittedAll;
+      break;
+    case MEMBER_DISCONNECTED:
+      mType = Disconnected;
+      break;
+    case MEMBER_CONNECT_ERROR:
+      mType = ConnectError;
+      break;
+    case MEMBER_GET_CHANGES_ERROR:
+      mType = GetChangesError;
+      break;
+    case MEMBER_COMMITTED_ALL_ERROR:
+      mType = CommittedAllError;
+      break;
+    case MEMBER_SYNC_DONE_ERROR:
+      mType = SyncDoneError;
+      break;
+    case MEMBER_DISCONNECT_ERROR:
+      mType = DisconnectedError;
+      break;
+  }
+
+  if ( update->error )
+    mResult = Result( &(update->error) );
+
+  mMember.mMember = update->member;
+}
+
+SyncMemberUpdate::~SyncMemberUpdate()
+{
+}
+
+SyncMemberUpdate::Type SyncMemberUpdate::type() const
+{
+  return mType;
+}
+
+Result SyncMemberUpdate::result() const
+{
+  return mResult;
+}
+
+Member SyncMemberUpdate::member() const
+{
+  return mMember;
+}
+
+
+SyncChangeUpdate::SyncChangeUpdate()
+{
+}
+
+SyncChangeUpdate::SyncChangeUpdate( OSyncChangeUpdate *update )
+{
+  switch ( update->type ) {
+    case CHANGE_RECEIVED:
+      mType = Received;
+      break;
+    case CHANGE_RECEIVED_INFO:
+      mType = ReceivedInfo;
+      break;
+    case CHANGE_SENT:
+      mType = Sent;
+      break;
+    case CHANGE_WRITE_ERROR:
+      mType = WriteError;
+      break;
+    case CHANGE_RECV_ERROR:
+      mType = ReceiveError;
+      break;
+  }
+
+  if ( update->error )
+    mResult = Result( &(update->error) );
+
+  mChange = SyncChange( update->change );
+  mMemberId = update->member_id;
+  mMappingId = update->mapping_id;
+}
+
+SyncChangeUpdate::~SyncChangeUpdate()
+{
+}
+
+SyncChangeUpdate::Type SyncChangeUpdate::type() const
+{
+  return mType;
+}
+
+Result SyncChangeUpdate::result() const
+{
+  return mResult;
+}
+
+SyncChange SyncChangeUpdate::change() const
+{
+  return mChange;
+}
+
+int SyncChangeUpdate::memberId() const
+{
+  return mMemberId;
+}
+
+int SyncChangeUpdate::mappingId() const
+{
+  return mMappingId;
+}
+
+SyncMappingUpdate::SyncMappingUpdate()
+{
+}
+
+SyncMappingUpdate::SyncMappingUpdate( OSyncMappingUpdate *update, OSyncEngine *engine )
+{
+  switch ( update->type ) {
+    case MAPPING_SOLVED:
+      mType = Solved;
+      break;
+    case MAPPING_SYNCED:
+      mType = Synced;
+      break;
+    case MAPPING_WRITE_ERROR:
+      mType = WriteError;
+      break;
+  }
+
+  if ( update->error )
+    mResult = Result( &(update->error) );
+
+  mWinner = update->winner;
+  mMapping.mEngine = engine;
+  mMapping.mMapping = update->mapping;
+}
+
+SyncMappingUpdate::~SyncMappingUpdate()
+{
+}
+
+SyncMappingUpdate::Type SyncMappingUpdate::type() const
+{
+  return mType;
+}
+
+Result SyncMappingUpdate::result() const
+{
+  return mResult;
+}
+
+long long int SyncMappingUpdate::winner() const
+{
+  return mWinner;
+}
+
+SyncMapping SyncMappingUpdate::mapping() const
+{
+  return mMapping;
+}
+
+SyncEngineUpdate::SyncEngineUpdate()
+{
+}
+
+SyncEngineUpdate::SyncEngineUpdate( OSyncEngineUpdate *update )
+{
+  switch ( update->type ) {
+    case ENG_ENDPHASE_CON:
+      mType = EndPhaseConnected;
+      break;
+    case ENG_ENDPHASE_READ:
+      mType = EndPhaseRead;
+      break;
+    case ENG_ENDPHASE_WRITE:
+      mType = EndPhaseWrite;
+      break;
+    case ENG_ENDPHASE_DISCON:
+      mType = EndPhaseDisconnected;
+      break;
+    case ENG_ERROR:
+      mType = Error;
+      break;
+    case ENG_SYNC_SUCCESSFULL:
+      mType = SyncSuccessfull;
+      break;
+    case ENG_PREV_UNCLEAN:
+      mType = PrevUnclean;
+      break;
+    case ENG_END_CONFLICTS:
+      mType = EndConflicts;
+      break;
+  }
+
+  if ( update->error )
+    mResult = Result( &(update->error) );
+}
+
+SyncEngineUpdate::~SyncEngineUpdate()
+{
+}
+
+SyncEngineUpdate::Type SyncEngineUpdate::type() const
+{
+  return mType;
+}
+
+Result SyncEngineUpdate::result() const
+{
+  return mResult;
+}
+
diff --git a/kitchensync/libqopensync/syncupdates.h b/kitchensync/libqopensync/syncupdates.h
new file mode 100644
index 000000000..14a2d9193
--- /dev/null
+++ b/kitchensync/libqopensync/syncupdates.h
@@ -0,0 +1,157 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+
+    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 QSYNC_SYNCUPDATES_H
+#define QSYNC_SYNCUPDATES_H
+
+#include <libqopensync/member.h>
+#include <libqopensync/result.h>
+#include <libqopensync/syncchange.h>
+#include <libqopensync/syncmapping.h>
+
+class OSyncMemberUpdate;
+class OSyncChangeUpdate;
+class OSyncMappingUpdate;
+class OSyncEngineUpdate;
+class OSyncMemberUpdate;
+
+namespace QSync {
+
+class SyncMemberUpdate
+{
+  friend class CallbackHandler;
+
+  public:
+    enum Type {
+      Connected,
+      SentChanges,
+      CommittedAll,
+      Disconnected,
+      ConnectError,
+      GetChangesError,
+      CommittedAllError,
+      SyncDoneError,
+      DisconnectedError
+    };
+
+    SyncMemberUpdate();
+    SyncMemberUpdate( OSyncMemberUpdate* );
+    ~SyncMemberUpdate();
+
+    Type type() const;
+    Result result() const;
+    Member member() const;
+
+  private:
+    Type mType;
+    Result mResult;
+    Member mMember;
+};
+
+class SyncChangeUpdate
+{
+  friend class CallbackHandler;
+
+  public:
+    enum Type {
+      Received = 1,
+      ReceivedInfo,
+      Sent,
+      WriteError,
+      ReceiveError
+    };
+
+    SyncChangeUpdate();
+    SyncChangeUpdate( OSyncChangeUpdate* );
+    ~SyncChangeUpdate();
+
+    Type type() const;
+    Result result() const;
+    SyncChange change() const;
+    int memberId() const;
+    int mappingId() const;
+
+  private:
+    Type mType;
+    Result mResult;
+    SyncChange mChange;
+    int mMemberId;
+    int mMappingId;
+};
+
+class SyncMappingUpdate
+{
+  friend class CallbackHandler;
+
+  public:
+    enum Type {
+      Solved = 1,
+      Synced,
+      WriteError
+    };
+
+    SyncMappingUpdate();
+    SyncMappingUpdate( OSyncMappingUpdate*, OSyncEngine* );
+    ~SyncMappingUpdate();
+
+    Type type() const;
+    Result result() const;
+    long long int winner() const;
+    SyncMapping mapping() const;
+
+  private:
+    Type mType;
+    Result mResult;
+    long long int mWinner;
+    SyncMapping mMapping;
+};
+
+class SyncEngineUpdate
+{
+  friend class CallbackHandler;
+
+  public:
+    enum Type {
+      EndPhaseConnected = 1,
+      EndPhaseRead,
+      EndPhaseWrite,
+      EndPhaseDisconnected,
+      Error,
+      SyncSuccessfull,
+      PrevUnclean,
+      EndConflicts
+    };
+
+    SyncEngineUpdate();
+    SyncEngineUpdate( OSyncEngineUpdate* );
+    ~SyncEngineUpdate();
+
+    Type type() const;
+    Result result() const;
+
+  private:
+    Type mType;
+    Result mResult;
+};
+
+}
+
+#endif