Part 2/2 of Chakra patch commit

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1172727 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

50 files changed, 1205 insertions, 556 deletions

diff --git a/kitchensync/configure.in.bot b/kitchensync/configure.in.bot
index a612d1b78..484225aab 100644
--- a/kitchensync/configure.in.bot
+++ b/kitchensync/configure.in.bot
@@ -1,7 +1,7 @@
-if test "$HAVE_OPENSYNC" = 0 -o "$HAVE_OPENSYNC_ENGINE" = 0; then
+if test "$HAVE_OPENSYNC" = 0; then
 	echo ""
 	echo "You're missing a compatible version of libopensync."
-        echo "Version 0.19 or greater is needed."
+        echo "Version 0.31 or greater is needed."
 	echo "kitchensync will not be built."
 	echo ""
 	all_tests=bad
diff --git a/kitchensync/configure.in.in b/kitchensync/configure.in.in
index 31bb902c6..2aeebedcb 100644
--- a/kitchensync/configure.in.in
+++ b/kitchensync/configure.in.in
@@ -29,9 +29,7 @@ export PKG_CONFIG_PATH=${PKG_CONFIG_PATH}:$prefix/lib/pkgconfig:/usr/local/lib/p
 
 
 HAVE_OPENSYNC=0
-HAVE_OPENSYNC_ENGINE=0
-PKG_CHECK_MODULES(OPENSYNC, opensync-1.0 >= 0.19, HAVE_OPENSYNC=1,HAVE_OPENSYNC=0)
-PKG_CHECK_MODULES(OPENSYNCENGINE, osengine-1.0 >= 0.19, HAVE_OPENSYNC_ENGINE=1, HAVE_OPENSYNC_ENGINE=0)
+PKG_CHECK_MODULES(OPENSYNC, opensync-1.0 >= 0.33, HAVE_OPENSYNC=1,HAVE_OPENSYNC=0)
 PKG_CHECK_MODULES(LIBXML,   libxml-2.0, , HAVE_OPENSYNC=0)
 PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.6, , HAVE_OPENSYNC=0)
 
@@ -52,9 +50,9 @@ AC_SUBST(OPENSYNC_FORMATSDIR)
 AC_SUBST(OPENSYNC_HEADERDIR)
 
 dnl Check if we can compile KitchenSync
-AM_CONDITIONAL(compile_kitchensync, test "$HAVE_OPENSYNC" = 1 -a "$HAVE_OPENSYNC_ENGINE" = 1)
+AM_CONDITIONAL(compile_kitchensync, test "$HAVE_OPENSYNC" = 1)
 
-if test "$HAVE_OPENSYNC" = 1 -a "$HAVE_OPENSYNC_ENGINE" = 1 ; then
+if test "$HAVE_OPENSYNC" = 1; then
     AC_MSG_RESULT([found])
 else
     AC_MSG_RESULT([not found])
diff --git a/kitchensync/libqopensync/Makefile.am b/kitchensync/libqopensync/Makefile.am
index 2e12df6ca..772146a47 100644
--- a/kitchensync/libqopensync/Makefile.am
+++ b/kitchensync/libqopensync/Makefile.am
@@ -2,16 +2,20 @@ INCLUDES = -I$(top_srcdir)/kitchensync/src \
            -I$(top_srcdir)/kitchensync \
            -I$(top_srcdir) \
            $(OPENSYNC_CFLAGS) \
-           $(OPENSYNCENGINE_CFLAGS) \
+           $(GLIB_CFLAGS) \
            $(all_includes)
 
 lib_LTLIBRARIES = libqopensync.la
 
-libqopensync_la_SOURCES = callbackhandler.cpp conversion.cpp engine.cpp environment.cpp filter.cpp group.cpp \
+libqopensync_la_SOURCES = callbackhandler.cpp engine.cpp groupenv.cpp pluginenv.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)
+
+# FIXME: -no-undefined break the build for some unkown reason - libopensync broken?!
+#libqopensync_la_LDFLAGS = $(all_libraries) $(KDE_RPATH) -no-undefined
+libqopensync_la_LDFLAGS = $(all_libraries) $(KDE_RPATH)
+libqopensync_la_LIBADD = $(LIB_KDEUI) $(OPENSYNC_LIBS)
+
 
 METASOURCES = AUTO
 
diff --git a/kitchensync/libqopensync/callbackhandler.cpp b/kitchensync/libqopensync/callbackhandler.cpp
index 504afea99..894261b37 100644
--- a/kitchensync/libqopensync/callbackhandler.cpp
+++ b/kitchensync/libqopensync/callbackhandler.cpp
@@ -19,12 +19,13 @@
     Boston, MA 02110-1301, USA.
 */
 
-#include <osengine/engine.h>
-
-#include <libqopensync/engine.h>
+#include <opensync/opensync.h>
+#include <opensync/opensync-engine.h>
 
 #include <tqapplication.h>
 
+#include "engine.h"
+
 #include "callbackhandler.h"
 
 using namespace QSync;
@@ -111,11 +112,11 @@ 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 );
+  osync_engine_set_conflict_callback( engine->mEngine, &conflict_callback, this );
+  osync_engine_set_changestatus_callback( engine->mEngine, &change_callback, this );
+  osync_engine_set_mappingstatus_callback( engine->mEngine, &mapping_callback, this );
+  osync_engine_set_enginestatus_callback( engine->mEngine, &engine_callback, this );
+  osync_engine_set_memberstatus_callback( engine->mEngine, &member_callback, this );
 }
 
 Engine* CallbackHandler::engine() const
@@ -143,7 +144,7 @@ void CallbackHandler::customEvent( TQCustomEvent *event )
   }
 }
 
-void CallbackHandler::conflict_callback( OSyncEngine *engine, OSyncMapping *omapping, void *data )
+void CallbackHandler::conflict_callback( OSyncEngine *engine, OSyncMappingEngine *omapping, void *data )
 {
   SyncMapping mapping( omapping, engine );
 
@@ -152,7 +153,7 @@ void CallbackHandler::conflict_callback( OSyncEngine *engine, OSyncMapping *omap
   TQApplication::postEvent( handler, new ConflictEvent( mapping ) );
 }
 
-void CallbackHandler::change_callback( OSyncEngine*, OSyncChangeUpdate *update, void *data )
+void CallbackHandler::change_callback( OSyncChangeUpdate *update, void *data )
 {
   SyncChangeUpdate change( update );
 
@@ -170,7 +171,7 @@ void CallbackHandler::mapping_callback( OSyncMappingUpdate *update, void *data )
   TQApplication::postEvent( handler, new MappingEvent( mapping ) );
 }
 
-void CallbackHandler::engine_callback( OSyncEngine*, OSyncEngineUpdate *update, void *data )
+void CallbackHandler::engine_callback( OSyncEngineUpdate *update, void *data )
 {
   SyncEngineUpdate engine( update );
 
diff --git a/kitchensync/libqopensync/callbackhandler.h b/kitchensync/libqopensync/callbackhandler.h
index fa6b97c60..a2a4c6d13 100644
--- a/kitchensync/libqopensync/callbackhandler.h
+++ b/kitchensync/libqopensync/callbackhandler.h
@@ -76,10 +76,10 @@ class CallbackHandler : public QObject
     class EngineEvent;
     class MemberEvent;
 
-    static void conflict_callback( OSyncEngine*, OSyncMapping*, void* );
-    static void change_callback( OSyncEngine*, OSyncChangeUpdate*, void* );
+    static void conflict_callback( OSyncEngine*, OSyncMappingEngine*, void* );
+    static void change_callback( OSyncChangeUpdate*, void* );
     static void mapping_callback( OSyncMappingUpdate*, void* );
-    static void engine_callback( OSyncEngine*, OSyncEngineUpdate*, void* );
+    static void engine_callback( OSyncEngineUpdate*, void* );
     static void member_callback( OSyncMemberUpdate*, void* );
 
     Engine* mEngine;
diff --git a/kitchensync/libqopensync/conversion.cpp b/kitchensync/libqopensync/conversion.cpp
index 0be2fdb73..dac027b1c 100644
--- a/kitchensync/libqopensync/conversion.cpp
+++ b/kitchensync/libqopensync/conversion.cpp
@@ -20,6 +20,7 @@
 */
 
 #include <opensync/opensync.h>
+#include <opensync/opensync-format.h>
 
 #include "conversion.h"
 
@@ -43,16 +44,20 @@ TQStringList Conversion::objectTypes() const
 {
   Q_ASSERT( mEnvironment );
 
-  OSyncFormatEnv *formatEnv = osync_conv_env_new( mEnvironment );
+  OSyncError *error = NULL;
+  OSyncFormatEnv *formatEnv = osync_format_env_new( &error );
   Q_ASSERT( formatEnv );
 
+  osync_format_env_load_plugins(formatEnv, NULL, &error);
+
   TQStringList types;	
-  for ( int i = 0; i < osync_conv_num_objtypes( formatEnv ); i++ ) {
-    OSyncObjType *type = osync_conv_nth_objtype( formatEnv, i );
-    types.append( TQString::fromUtf8( osync_objtype_get_name( type ) ) );
-  }
 
-  osync_conv_env_free( formatEnv );
+  for (int i = 0; i < osync_format_env_num_objformats(formatEnv); i++) {
+    OSyncObjFormat *format = osync_format_env_nth_objformat(formatEnv, i);
+    types.append( TQString::fromUtf8( osync_objformat_get_objtype(format) ) );
+ }
+
+  osync_format_env_free( formatEnv );
 
   return types;
 }
diff --git a/kitchensync/libqopensync/conversion.h b/kitchensync/libqopensync/conversion.h
index e4b32c580..88447dbbe 100644
--- a/kitchensync/libqopensync/conversion.h
+++ b/kitchensync/libqopensync/conversion.h
@@ -24,13 +24,13 @@
 
 #include <tqstringlist.h>
 
-class OSyncEnv;
+class OSyncGroupEnv;
 
 namespace QSync {
 
 class Conversion
 {
-  friend class Environment;
+  friend class PluginEnv;
 
   public:
     Conversion();
@@ -47,7 +47,7 @@ class Conversion
     TQStringList objectTypes() const;
 
   private:
-    OSyncEnv *mEnvironment;
+    OSyncGroupEnv *mGroupEnv;
 };
 
 }
diff --git a/kitchensync/libqopensync/engine.cpp b/kitchensync/libqopensync/engine.cpp
index 6d48c72ff..64a11f0ed 100644
--- a/kitchensync/libqopensync/engine.cpp
+++ b/kitchensync/libqopensync/engine.cpp
@@ -20,7 +20,11 @@
 */
 
 #include <opensync/opensync.h>
-#include <osengine/engine.h>
+#include <opensync/opensync-engine.h>
+
+#include "group.h"
+#include "member.h"
+#include "result.h"
 
 #include "engine.h"
 
@@ -29,19 +33,21 @@ using namespace QSync;
 Engine::Engine( const Group &group )
 {
   OSyncError *error = 0;
-  mEngine = osengine_new( group.mGroup, &error );
+  mEngine = osync_engine_new( group.mGroup, &error );
 }
 
 Engine::~Engine()
 {
-  osengine_free( mEngine );
+  osync_engine_unref( mEngine );
   mEngine = 0;
 }
 
 Result Engine::initialize()
 {
+  Q_ASSERT( mEngine );
+
   OSyncError *error = 0;
-  if ( !osengine_init( mEngine, &error ) )
+  if ( !osync_engine_initialize	( mEngine, &error ) )
     return Result( &error );
   else
     return Result();
@@ -49,13 +55,29 @@ Result Engine::initialize()
 
 void Engine::finalize()
 {
-  osengine_finalize( mEngine );
+  Q_ASSERT( mEngine );
+
+  OSyncError *error = 0;
+  osync_engine_finalize( mEngine , &error );
 }
 
 Result Engine::synchronize()
 {
+  Q_ASSERT( mEngine );
+
   OSyncError *error = 0;
-  if ( !osengine_synchronize( mEngine, &error ) )
+  if ( !osync_engine_synchronize( mEngine, &error ) )
+    return Result( &error );
+  else
+    return Result();
+}
+
+Result Engine::discover( const Member &member )
+{
+  Q_ASSERT( mEngine );
+
+  OSyncError *error = 0;
+  if ( !osync_engine_discover_and_block( mEngine, member.mMember, &error ) )
     return Result( &error );
   else
     return Result();
@@ -63,5 +85,9 @@ Result Engine::synchronize()
 
 void Engine::abort()
 {
-  osengine_abort( mEngine );
+  Q_ASSERT( mEngine );
+
+// TODO
+//  osync_engine_abort( mEngine );
 }
+
diff --git a/kitchensync/libqopensync/engine.h b/kitchensync/libqopensync/engine.h
index e62a5f689..c7314db47 100644
--- a/kitchensync/libqopensync/engine.h
+++ b/kitchensync/libqopensync/engine.h
@@ -22,12 +22,14 @@
 #ifndef QSYNC_ENGINE_H
 #define QSYNC_ENGINE_H
 
-#include <libqopensync/group.h>
-
 class OSyncEngine;
 
 namespace QSync {
 
+class Group;
+class Member;
+class Result;
+
 class Engine
 {
   friend class CallbackHandler;
@@ -59,6 +61,11 @@ class Engine
     Result synchronize();
 
     /**
+      Starts the discover process for a certain member.
+     */
+    Result discover( const Member &member );
+
+    /**
       Stops the synchronization process.
      */
     void abort();
diff --git a/kitchensync/libqopensync/filter.cpp b/kitchensync/libqopensync/filter.cpp
index dc5fe2eee..35e128968 100644
--- a/kitchensync/libqopensync/filter.cpp
+++ b/kitchensync/libqopensync/filter.cpp
@@ -20,6 +20,7 @@
 */
 
 #include <opensync/opensync.h>
+#include <opensync/opensync-format.h>
 
 #include "filter.h"
 
diff --git a/kitchensync/libqopensync/group.cpp b/kitchensync/libqopensync/group.cpp
index bc94e2208..46e106098 100644
--- a/kitchensync/libqopensync/group.cpp
+++ b/kitchensync/libqopensync/group.cpp
@@ -25,86 +25,18 @@
 /** hack includes **/
 
 #include <opensync/opensync.h>
+#include <opensync/opensync-group.h>
 
 #include "conversion.h"
+#include "filter.h"
+#include "member.h"
+#include "plugin.h"
+#include "result.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 )
-{
-}
-
-TQStringList GroupConfig::activeObjectTypes() const
-{
-  Q_ASSERT( mGroup );
-
-  const TQString fileName = TQString( "%1/filter.conf" ).arg( osync_group_get_configdir( mGroup ) );
-
-  TQFile file( fileName );
-  if ( !file.open( IO_ReadOnly ) )
-    return TQStringList();
-
-  TQDomDocument document;
-
-  TQString message;
-  if ( !document.setContent( &file, &message ) ) {
-    qDebug( "Error on loading %s: %s", fileName.latin1(), message.latin1() );
-    return TQStringList();
-  }
-  file.close();
-
-  TQStringList objectTypes;
-
-  TQDomElement element = document.documentElement();
-  TQDomNode node = element.firstChild();
-  while ( !node.isNull() ) {
-    TQDomElement childElement = node.toElement();
-    if ( !childElement.isNull() )
-      objectTypes.append( childElement.tagName() );
-
-    node = node.nextSibling();
-  }
-
-  return objectTypes;
-}
-
-void GroupConfig::setActiveObjectTypes( const TQStringList &objectTypes )
-{
-  Q_ASSERT( mGroup );
-
-  TQDomDocument document( "Filter" );
-  document.appendChild( document.createProcessingInstruction(
-                        "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
-
-  TQDomElement element = document.createElement( "filter" );
-  document.appendChild( element );
-
-  for ( uint i = 0; i < objectTypes.count(); ++i ) {
-    TQDomElement entry = document.createElement( objectTypes[ i ] );
-    element.appendChild( entry );
-  }
-
-  const TQString fileName = TQString( "%1/filter.conf" ).arg( osync_group_get_configdir( mGroup ) );
-
-  TQFile file( fileName );
-  if ( !file.open( IO_WriteOnly ) )
-    return;
-
-  TQTextStream s( &file );
-  s.setEncoding( TQTextStream::UnicodeUTF8 );
-  s << document.toString();
-  file.close();
-}
-
-
 Group::Group()
   : mGroup( 0 )
 {
@@ -119,22 +51,6 @@ 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 TQString &name )
 {
   Q_ASSERT( mGroup );
@@ -188,18 +104,22 @@ Group::LockType Group::lock()
   }
 }
 
-void Group::unlock( bool removeFile )
+void Group::unlock()
 {
   Q_ASSERT( mGroup );
 
-  osync_group_unlock( mGroup, removeFile );
+  osync_group_unlock( mGroup );
 }
 
-Member Group::addMember()
+Member Group::addMember( const QSync::Plugin &plugin )
 {
   Q_ASSERT( mGroup );
 
-  OSyncMember *omember = osync_member_new( mGroup );
+  OSyncError *error = 0;
+
+  OSyncMember *omember = osync_member_new( &error );
+  osync_group_add_member( mGroup, omember );
+  osync_member_set_pluginname( omember, plugin.name().utf8() );
 
   Member member;
   member.mMember = omember;
@@ -269,6 +189,30 @@ Result Group::save()
     return Result();
 }
 
+void Group::setUseMerger( bool use )
+{
+  Q_ASSERT( mGroup );
+  osync_group_set_merger_enabled( mGroup, use );
+}
+
+bool Group::useMerger() const
+{
+  Q_ASSERT( mGroup );
+  return osync_group_get_merger_enabled( mGroup );
+}
+
+void Group::setUseConverter( bool use )
+{
+  Q_ASSERT( mGroup );
+  osync_group_set_converter_enabled( mGroup, use );
+}
+
+bool Group::useConverter() const
+{
+  Q_ASSERT( mGroup );
+  return osync_group_get_converter_enabled( mGroup );
+}
+
 void Group::setObjectTypeEnabled( const TQString &objectType, bool enabled )
 {
   Q_ASSERT( mGroup );
@@ -281,12 +225,13 @@ bool Group::isObjectTypeEnabled( const TQString &objectType ) const
   return osync_group_objtype_enabled( mGroup, objectType.utf8() );
 }
 
-GroupConfig Group::config() const
+Result Group::cleanup() const
 {
   Q_ASSERT( mGroup );
 
-  GroupConfig config;
-  config.mGroup = mGroup;
-
-  return config;
+  OSyncError *error = 0;
+  if ( !osync_group_delete( mGroup, &error ) )
+    return Result( &error );
+  else
+    return Result();
 }
diff --git a/kitchensync/libqopensync/group.h b/kitchensync/libqopensync/group.h
index 750e7c41c..1b1a532c3 100644
--- a/kitchensync/libqopensync/group.h
+++ b/kitchensync/libqopensync/group.h
@@ -25,35 +25,22 @@
 #include <tqdatetime.h>
 #include <tqstringlist.h>
 
-#include <libqopensync/filter.h>
-#include <libqopensync/member.h>
-
 class OSyncGroup;
 
 namespace QSync {
 
+class Filter;
+class Member;
+class Plugin;
+class Result;
+
 /**
   @internal
  */
-class GroupConfig
-{
-  friend class Group;
-
-  public:
-    GroupConfig();
-
-    TQStringList activeObjectTypes() const;
-    void setActiveObjectTypes( const TQStringList &objectTypes );
-
-  private:
-    OSyncGroup *mGroup;
-};
-
-
 class Group
 {
   friend class Engine;
-  friend class Environment;
+  friend class GroupEnv;
 
   public:
     enum LockType
@@ -71,51 +58,6 @@ class 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.
      */
@@ -145,17 +87,15 @@ class Group
 
     /**
       Unlocks the group.
-
-      @param removeFile Whether the lock file shall be removed.
      */
-    void unlock( bool removeFile = true );
+    void unlock();
 
     /**
       Adds a new member to the group.
 
       @returns the new member.
      */
-    Member addMember();
+    Member addMember( const QSync::Plugin &plugin );
 
     /**
       Removes a member from the group.
@@ -195,19 +135,37 @@ class Group
     bool isObjectTypeEnabled( const TQString &objectType ) const;
 
     /**
-      Saves the configuration to hard disc.
+      Sets whether this group uses the merger for synchronization.
      */
-    Result save();
+    void setUseMerger( bool use );
+
+    /**
+      Returns whether this group uses the merger for synchronization.
+     */
+    bool useMerger() const;
+
+    /**
+      Sets whether this group uses the converter for synchronization.
+     */
+    void setUseConverter( bool use );
 
     /**
-      Returns the config object of this group.
+      Returns whether this group uses the converter for synchronization.
+     */
+    bool useConverter() const;
 
-      Note: This method is only available for OpenSync 0.19 and 0.20.
+    /**
+      Saves the configuration to hard disc.
      */
-    GroupConfig config() const;
+    Result save();
 
     bool operator==( const Group &group ) const { return mGroup == group.mGroup; }
 
+    /**
+      Removes all group configurations from the hard disc.
+     */
+    Result cleanup() const;
+
   private:
     OSyncGroup *mGroup;
 };
diff --git a/kitchensync/libqopensync/groupenv.cpp b/kitchensync/libqopensync/groupenv.cpp
new file mode 100644
index 000000000..bd6b3b680
--- /dev/null
+++ b/kitchensync/libqopensync/groupenv.cpp
@@ -0,0 +1,121 @@
+/*
+    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 <opensync/opensync-group.h>
+
+#include "group.h"
+#include "result.h"
+
+#include "groupenv.h"
+
+using namespace QSync;
+
+GroupEnv::GroupEnv()
+{
+  OSyncError *error = 0;
+  mGroupEnv = osync_group_env_new( &error );
+}
+
+GroupEnv::~GroupEnv()
+{
+  osync_group_env_free( mGroupEnv );
+}
+
+Result GroupEnv::initialize()
+{
+  Q_ASSERT( mGroupEnv );
+
+  OSyncError *error = 0;
+  if ( !osync_group_env_load_groups( mGroupEnv, NULL, &error ) )
+    return Result( &error );
+  else
+    return Result();
+}
+
+void GroupEnv::finalize()
+{
+}
+
+int GroupEnv::groupCount() const
+{
+  Q_ASSERT( mGroupEnv );
+
+  return osync_group_env_num_groups( mGroupEnv );
+}
+
+Group GroupEnv::groupAt( int pos ) const
+{
+  Q_ASSERT( mGroupEnv );
+
+  Group group;
+
+  if ( pos < 0 || pos >= groupCount() )
+    return group;
+
+  OSyncGroup *ogroup = osync_group_env_nth_group( mGroupEnv, pos );
+  group.mGroup = ogroup;
+
+  return group;
+}
+
+Group GroupEnv::groupByName( const TQString &name ) const
+{
+  Q_ASSERT( mGroupEnv );
+
+  Group group;
+
+  OSyncGroup *ogroup = osync_group_env_find_group( mGroupEnv, name.latin1() );
+  if ( ogroup )
+    group.mGroup = ogroup;
+
+  return group;
+}
+
+Group GroupEnv::addGroup( const TQString &name )
+{
+  Q_ASSERT( mGroupEnv );
+
+  Group group;
+  OSyncError *error = 0;
+
+  OSyncGroup *ogroup = osync_group_new( &error );
+  if ( ogroup )
+    group.mGroup = ogroup;
+
+  group.setName( name );
+
+  if ( !osync_group_env_add_group( mGroupEnv, ogroup, &error ) ) {
+    Result res( &error );
+    qDebug( "Error on adding group: %s", res.message().latin1() );
+  }
+
+  return group;
+}
+
+void GroupEnv::removeGroup( const Group &group )
+{
+  Q_ASSERT( mGroupEnv );
+
+  group.cleanup();
+
+  osync_group_env_remove_group( mGroupEnv, group.mGroup );
+}
diff --git a/kitchensync/libqopensync/groupenv.h b/kitchensync/libqopensync/groupenv.h
new file mode 100644
index 000000000..80179826d
--- /dev/null
+++ b/kitchensync/libqopensync/groupenv.h
@@ -0,0 +1,86 @@
+/*
+    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_GROUPENV_H
+#define OSYNC_GROUPENV_H
+
+#include <tqstring.h>
+
+struct OSyncGroupEnv;
+
+namespace QSync {
+
+class Group;
+class Result;
+
+class GroupEnv
+{
+  public:
+    GroupEnv();
+    ~GroupEnv();
+
+    /**
+      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.
+     */
+    void 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 TQString &name ) const;
+
+    /**
+      Adds a new group to the environment.
+
+      @returns the new group.
+     */
+    Group addGroup( const TQString &name );
+
+    /**
+      Removes a group from the environment.
+     */
+    void removeGroup( const Group &group );
+
+  private:
+    OSyncGroupEnv *mGroupEnv;
+};
+
+}
+
+#endif
diff --git a/kitchensync/libqopensync/member.cpp b/kitchensync/libqopensync/member.cpp
index 35cb04632..e56d11829 100644
--- a/kitchensync/libqopensync/member.cpp
+++ b/kitchensync/libqopensync/member.cpp
@@ -20,8 +20,12 @@
 */
 
 #include <opensync/opensync.h>
+#include <opensync/opensync-group.h>
+
 #include <stdlib.h>
 
+#include "result.h"
+
 #include "member.h"
 
 using namespace QSync;
@@ -42,9 +46,9 @@ bool Member::isValid() const
   if ( !mMember )
     return false;
 
-  if ( !osync_member_instance_plugin( mMember, pluginName().utf8(), &error ) ) {
+  if ( !osync_member_load( mMember, configurationDirectory().utf8(), &error ) ) {
     qDebug( "Plugin %s is not valid: %s", pluginName().latin1(), osync_error_print( &error ) );
-    osync_error_free( &error );
+    osync_error_unref( &error );
     return false;
   }
 
@@ -65,19 +69,6 @@ TQString Member::pluginName() const
   return TQString::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 );
@@ -103,27 +94,28 @@ void Member::setConfiguration( const TQByteArray &configurationData )
 {
   Q_ASSERT( mMember );
 
-  osync_member_set_config( mMember, configurationData.data(), configurationData.size() );
+  osync_member_set_config( mMember, configurationData.data() );
 }
 
 Result Member::configuration( TQByteArray &configurationData, bool useDefault )
 {
   Q_ASSERT( mMember );
 
-  char *data;
-  int size;
+  const char *data;
+  int size = 0;
 
   OSyncError *error = 0;
-  osync_bool ok = false;
   if ( useDefault )
-    ok = osync_member_get_config_or_default( mMember, &data, &size, &error );
+    data = osync_member_get_config_or_default( mMember, &error );
   else
-    ok = osync_member_get_config( mMember, &data, &size, &error );
+    data = osync_member_get_config( mMember, &error );
 
-  if ( !ok ) {
+
+  if ( !data ) {
     return Result( &error );
   } else {
-    configurationData.resize( size );
+    size = strlen(data);
+    configurationData.resize( size );	  
     memcpy( configurationData.data(), data, size );
 
     return Result();
@@ -141,10 +133,10 @@ Result Member::save()
     return Result();
 }
 
-Result Member::instance( const Plugin &plugin )
+Result Member::instance()
 {
   OSyncError *error = 0;
-  if ( !osync_member_instance_plugin( mMember, plugin.name().utf8(), &error ) )
+  if ( !osync_member_load( mMember, configurationDirectory().utf8(), &error ) )
     return Result( &error );
   else
     return Result();
@@ -155,34 +147,13 @@ bool Member::operator==( const Member &member ) const
   return mMember == member.mMember;
 }
 
-TQString Member::scanDevices( const TQString &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 TQString();
-  } else {
-    TQString xml = TQString::fromUtf8( data );
-    free( data );
-    return xml;
-  }
-}
-
-bool Member::testConnection( const TQString &configuration )
+Result Member::cleanup() const
 {
   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;
-  }
+  if ( !osync_member_delete( mMember, &error ) )
+    return Result( &error );
+  else
+    return Result();
 }
diff --git a/kitchensync/libqopensync/member.h b/kitchensync/libqopensync/member.h
index 294c19f15..215b0b148 100644
--- a/kitchensync/libqopensync/member.h
+++ b/kitchensync/libqopensync/member.h
@@ -22,19 +22,21 @@
 #ifndef QSYNC_MEMBER_H
 #define QSYNC_MEMBER_H
 
-#include <libqopensync/plugin.h>
-#include <libqopensync/result.h>
-#include <libqopensync/plugin.h>
+#include <tqstring.h>
 
 class OSyncMember;
 
 namespace QSync {
 
+class Result;
+
 class Member
 {
   friend class Group;
+  friend class Engine;
   friend class SyncChange;
   friend class SyncMemberUpdate;
+  friend class SyncChangeUpdate;
 
   public:
     Member();
@@ -56,11 +58,6 @@ class Member
     TQString pluginName() const;
 
     /**
-      Returns the plugin, the member belongs to.
-     */
-    Plugin plugin() const;
-
-    /**
       Returns the id of the plugin.
     */
     int id() const;
@@ -102,7 +99,7 @@ class Member
     /**
       Make this member an instance of the given plugin.
     */
-    Result instance( const Plugin & );
+    Result instance();
 
     bool operator==( const Member& ) const;
 
@@ -119,6 +116,12 @@ class Member
      */
     bool testConnection( const TQString &configuration );
 
+
+    /**
+     * Deletes the member's information from the hard disc.
+     */
+    Result cleanup() const;
+
   private:
     OSyncMember *mMember;
 };
diff --git a/kitchensync/libqopensync/plugin.cpp b/kitchensync/libqopensync/plugin.cpp
index acd54447a..a9437f387 100644
--- a/kitchensync/libqopensync/plugin.cpp
+++ b/kitchensync/libqopensync/plugin.cpp
@@ -20,6 +20,7 @@
 */
 
 #include <opensync/opensync.h>
+#include <opensync/opensync-plugin.h>
 
 #include "plugin.h"
 
diff --git a/kitchensync/libqopensync/plugin.h b/kitchensync/libqopensync/plugin.h
index d26c2826c..ddddaadbb 100644
--- a/kitchensync/libqopensync/plugin.h
+++ b/kitchensync/libqopensync/plugin.h
@@ -30,7 +30,7 @@ namespace QSync {
 
 class Plugin
 {
-  friend class Environment;
+  friend class PluginEnv;
   friend class Member;
 
   public:
diff --git a/kitchensync/libqopensync/pluginenv.cpp b/kitchensync/libqopensync/pluginenv.cpp
new file mode 100644
index 000000000..5efcb97b8
--- /dev/null
+++ b/kitchensync/libqopensync/pluginenv.cpp
@@ -0,0 +1,96 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+    Copyright (c) 2007 Daniel Gollub <dgollub@suse.de>
+
+    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 <opensync/opensync-plugin.h>
+
+#include "plugin.h"
+#include "result.h"
+
+#include "pluginenv.h"
+
+using namespace QSync;
+
+PluginEnv::PluginEnv()
+{
+  OSyncError *error = 0;
+  mPluginEnv = osync_plugin_env_new( &error );
+}
+
+PluginEnv::~PluginEnv()
+{
+  osync_plugin_env_free( mPluginEnv );
+}
+
+Result PluginEnv::initialize()
+{
+  OSyncError *error = 0;
+  if ( !osync_plugin_env_load( mPluginEnv, NULL, &error ) )
+    return Result( &error );
+  else
+    return Result();
+}
+
+Result PluginEnv::finalize()
+{
+  osync_plugin_env_free( mPluginEnv ); 
+  return Result();
+}
+
+int PluginEnv::pluginCount() const
+{
+  return osync_plugin_env_num_plugins( mPluginEnv );
+}
+
+Plugin PluginEnv::pluginAt( int pos ) const
+{
+  Plugin plugin;
+
+  if ( pos < 0 || pos >= pluginCount() )
+    return plugin;
+
+  OSyncPlugin *oplugin = osync_plugin_env_nth_plugin( mPluginEnv, pos );
+  plugin.mPlugin = oplugin;
+
+  return plugin;
+}
+
+Plugin PluginEnv::pluginByName( const TQString &name ) const
+{
+  Plugin plugin;
+
+  OSyncPlugin *oplugin = osync_plugin_env_find_plugin( mPluginEnv, name.latin1() );
+  if ( oplugin )
+    plugin.mPlugin = oplugin;
+
+  return plugin;
+}
+
+/*
+Conversion PluginEnv::conversion() const
+{
+  Conversion conversion;
+  conversion.mPluginEnv = mPluginEnv;
+
+  return conversion;
+}
+*/
diff --git a/kitchensync/libqopensync/pluginenv.h b/kitchensync/libqopensync/pluginenv.h
new file mode 100644
index 000000000..2acc4e54a
--- /dev/null
+++ b/kitchensync/libqopensync/pluginenv.h
@@ -0,0 +1,80 @@
+/*
+    This file is part of libqopensync.
+
+    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
+    Copyright (c) 2007 Daniel Gollub <dgollub@suse.de>
+
+    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_PLUGINENV_H
+#define OSYNC_PLUGINENV_H
+
+#include <tqstring.h>
+
+struct OSyncPluginEnv;
+
+namespace QSync {
+
+class Plugin;
+class Result;
+
+class PluginEnv
+{
+  public:
+    PluginEnv();
+    ~PluginEnv();
+
+    /**
+      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 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 TQString &name ) const;
+
+    /**
+      Returns the conversion object of this environment.
+     */
+//    Conversion conversion() const;
+
+  private:
+    OSyncPluginEnv *mPluginEnv;
+};
+
+}
+
+#endif
diff --git a/kitchensync/libqopensync/result.cpp b/kitchensync/libqopensync/result.cpp
index d38c32a3d..13d06e71a 100644
--- a/kitchensync/libqopensync/result.cpp
+++ b/kitchensync/libqopensync/result.cpp
@@ -100,7 +100,7 @@ Result::Result( OSyncError **error, bool deleteError )
   mMessage = TQString::fromUtf8( osync_error_print( error ) );
 
   if ( deleteError )
-    osync_error_free( error );
+    osync_error_unref( error );
 }
 
 Result::~Result()
diff --git a/kitchensync/libqopensync/syncchange.cpp b/kitchensync/libqopensync/syncchange.cpp
index 5dd72d7ff..d45be2e4a 100644
--- a/kitchensync/libqopensync/syncchange.cpp
+++ b/kitchensync/libqopensync/syncchange.cpp
@@ -19,8 +19,13 @@
     Boston, MA 02110-1301, USA.
 */
 
+#include <stdlib.h>
+
 #include <opensync/file.h>
+
 #include <opensync/opensync.h>
+#include <opensync/opensync-data.h>
+#include <opensync/opensync-format.h>
 
 #include "syncchange.h"
 
@@ -64,39 +69,50 @@ TQString SyncChange::hash() const
   return TQString::fromUtf8( osync_change_get_hash( mSyncChange ) );
 }
 
-void SyncChange::setData( const TQString &data )
+void SyncChange::setData( const TQString &data , OSyncObjFormat *format )
 {
-  osync_change_set_data( mSyncChange, const_cast<char*>( data.utf8().data() ), data.utf8().size(), true );
+  OSyncError *error = 0;	
+
+  OSyncData *odata = osync_data_new( const_cast<char*>( data.utf8().data() ), data.utf8().size(), format, &error );
+  osync_change_set_data( mSyncChange, odata );
 }
 
 TQString SyncChange::data() const
 {
-  int size = osync_change_get_datasize( mSyncChange );
+  char *buf;
+  unsigned int size;
+
+  OSyncData *data = osync_change_get_data( mSyncChange );
+
+  osync_data_get_data( data, &buf, &size );
 
   TQString content;
   if ( objectFormatName() == "file" ) {
-    fileFormat *format = (fileFormat*)osync_change_get_data( mSyncChange );
+    OSyncFileFormat *format = (OSyncFileFormat*) buf;
     if ( format )
       content = TQString::fromUtf8( format->data, format->size );
   } else
-    content = TQString::fromUtf8( osync_change_get_data( mSyncChange ), size );
+    content = TQString::fromUtf8( buf, size );
+
+  free( buf );
 
   return content;
 }
 
 bool SyncChange::hasData() const
 {
-  return osync_change_has_data( mSyncChange );
+  return osync_data_has_data( osync_change_get_data( mSyncChange ) );
 }
 
 TQString SyncChange::objectFormatName() const
 {
-  OSyncObjFormat *format = osync_change_get_objformat( mSyncChange );
+  OSyncObjFormat *format = osync_data_get_objformat( osync_change_get_data( mSyncChange ) );
   Q_ASSERT( format );
 
   return TQString::fromUtf8( osync_objformat_get_name( format ) );
 }
 
+/*
 Member SyncChange::member() const
 {
   OSyncMember *omember = osync_change_get_member( mSyncChange );
@@ -106,6 +122,7 @@ Member SyncChange::member() const
 
   return m;
 }
+*/
 
 void SyncChange::setChangeType( Type changeType )
 {
@@ -113,20 +130,20 @@ void SyncChange::setChangeType( Type changeType )
 
   switch ( changeType ) {
     case AddedChange:
-      ochangeType = CHANGE_ADDED;
+      ochangeType = OSYNC_CHANGE_TYPE_ADDED;
       break;
     case UnmodifiedChange:
-      ochangeType = CHANGE_UNMODIFIED;
+      ochangeType = OSYNC_CHANGE_TYPE_UNMODIFIED;
       break;
     case DeletedChange:
-      ochangeType = CHANGE_DELETED;
+      ochangeType = OSYNC_CHANGE_TYPE_DELETED;
       break;
     case ModifiedChange:
-      ochangeType = CHANGE_MODIFIED;
+      ochangeType = OSYNC_CHANGE_TYPE_MODIFIED;
       break;
     case UnknownChange:
     default:
-      ochangeType = CHANGE_UNKNOWN;
+      ochangeType = OSYNC_CHANGE_TYPE_UNKNOWN;
       break;
   }
 
@@ -138,19 +155,19 @@ SyncChange::Type SyncChange::changeType() const
   OSyncChangeType ochangeType = osync_change_get_changetype( mSyncChange );
 
   switch ( ochangeType ) {
-    case CHANGE_ADDED:
+    case OSYNC_CHANGE_TYPE_ADDED:
       return AddedChange;
       break;
-    case CHANGE_UNMODIFIED:
+    case OSYNC_CHANGE_TYPE_UNMODIFIED:
       return UnmodifiedChange;
       break;
-    case CHANGE_DELETED:
+    case OSYNC_CHANGE_TYPE_DELETED:
       return DeletedChange;
       break;
-    case CHANGE_MODIFIED:
+    case OSYNC_CHANGE_TYPE_MODIFIED:
       return ModifiedChange;
       break;
-    case CHANGE_UNKNOWN:
+    case OSYNC_CHANGE_TYPE_UNKNOWN:
     default:
       return UnknownChange;
       break;
diff --git a/kitchensync/libqopensync/syncchange.h b/kitchensync/libqopensync/syncchange.h
index 53d9c4401..2afaddcc4 100644
--- a/kitchensync/libqopensync/syncchange.h
+++ b/kitchensync/libqopensync/syncchange.h
@@ -25,6 +25,7 @@
 #include <libqopensync/member.h>
 
 class OSyncChange;
+class OSyncObjFormat;
 
 namespace QSync {
 
@@ -74,7 +75,7 @@ class SyncChange
     /**
       Sets the data provided by the plugin.
      */
-    void setData( const TQString &data );
+    void setData( const TQString &data, OSyncObjFormat *format );
 
     /**
       Returns the data provided by the plugin.
@@ -94,7 +95,7 @@ class SyncChange
     /**
       Returns the parent member of this change.
      */
-    Member member() const;
+//    Member member() const;
 
     /**
       Sets the change type.
diff --git a/kitchensync/libqopensync/syncmapping.cpp b/kitchensync/libqopensync/syncmapping.cpp
index 95939ab85..d716af17a 100644
--- a/kitchensync/libqopensync/syncmapping.cpp
+++ b/kitchensync/libqopensync/syncmapping.cpp
@@ -20,19 +20,20 @@
 */
 
 #include <tqstring.h>
-#include <osengine/engine.h>
+#include <opensync/opensync.h>
+#include <opensync/opensync-engine.h>
 
 #include "syncmapping.h"
 
 using namespace QSync;
 
 SyncMapping::SyncMapping()
-  : mEngine( 0 ), mMapping( 0 )
+  : mEngine( 0 ), mMappingEngine( 0 )
 {
 }
 
-SyncMapping::SyncMapping( OSyncMapping *mapping, OSyncEngine *engine )
-  : mEngine( engine ), mMapping( mapping )
+SyncMapping::SyncMapping( OSyncMappingEngine *mapping, OSyncEngine *engine )
+  : mEngine( engine ), mMappingEngine( mapping )
 {
 }
 
@@ -42,58 +43,64 @@ SyncMapping::~SyncMapping()
 
 bool SyncMapping::isValid() const
 {
-  return ( mEngine != 0 && mMapping != 0 );
+  return ( mEngine != 0 && mMappingEngine != 0 );
 }
 
+/*
 long long SyncMapping::id() const
 {
-  Q_ASSERT( mMapping );
+  Q_ASSERT( mMappingEngine );
 
-  return osengine_mapping_get_id( mMapping );
+  return osync_mapping_engine_get_id( mMappingEngine );
 }
+*/
 
 void SyncMapping::duplicate()
 {
   Q_ASSERT( mEngine );
-  Q_ASSERT( mMapping );
+  Q_ASSERT( mMappingEngine );
+
+  OSyncError *error = 0;
 
-  osengine_mapping_duplicate( mEngine, mMapping );
+  osync_mapping_engine_duplicate( mMappingEngine, &error );
 }
 
 void SyncMapping::solve( const SyncChange &change )
 {
   Q_ASSERT( mEngine );
-  Q_ASSERT( mMapping );
+  Q_ASSERT( mMappingEngine );
   Q_ASSERT( change.isValid() );
 
-  osengine_mapping_solve( mEngine, mMapping, change.mSyncChange );
+  OSyncError *error = 0;
+
+  osync_mapping_engine_solve( mMappingEngine, change.mSyncChange, &error );
 }
 
 void SyncMapping::ignore()
 {
   Q_ASSERT( mEngine );
-  Q_ASSERT( mMapping );
+  Q_ASSERT( mMappingEngine );
 
   //TODO: error should be returned as Result
   OSyncError *error = 0;
-  osengine_mapping_ignore_conflict( mEngine, mMapping, &error );
+  osync_mapping_engine_ignore( mMappingEngine, &error );
 }
 
 int SyncMapping::changesCount() const
 {
-  Q_ASSERT( mMapping );
+  Q_ASSERT( mMappingEngine );
 
-  return osengine_mapping_num_changes( mMapping );
+  return osync_mapping_engine_num_changes( mMappingEngine );
 }
 
 SyncChange SyncMapping::changeAt( int pos )
 {
-  Q_ASSERT( mMapping );
+  Q_ASSERT( mMappingEngine );
 
-  if ( pos < 0 || pos >= osengine_mapping_num_changes( mMapping ) )
+  if ( pos < 0 || pos >= osync_mapping_engine_num_changes( mMappingEngine ) )
     return SyncChange();
 
-  OSyncChange *ochange = osengine_mapping_nth_change( mMapping, pos );
+  OSyncChange *ochange = osync_mapping_engine_nth_change( mMappingEngine, pos );
 
   return SyncChange( ochange );
 }
diff --git a/kitchensync/libqopensync/syncmapping.h b/kitchensync/libqopensync/syncmapping.h
index 6de67330a..0351fa9f5 100644
--- a/kitchensync/libqopensync/syncmapping.h
+++ b/kitchensync/libqopensync/syncmapping.h
@@ -25,7 +25,7 @@
 #include <libqopensync/syncchange.h>
 
 class OSyncEngine;
-class OSyncMapping;
+class OSyncMappingEngine;
 
 namespace QSync {
 
@@ -35,7 +35,7 @@ class SyncMapping
 
   public:
     SyncMapping();
-    SyncMapping( OSyncMapping*, OSyncEngine* );
+    SyncMapping( OSyncMappingEngine*, OSyncEngine* );
     ~SyncMapping();
 
     bool isValid() const;
@@ -51,7 +51,7 @@ class SyncMapping
 
   private:
     OSyncEngine *mEngine;
-    OSyncMapping *mMapping;
+    OSyncMappingEngine *mMappingEngine;
 };
 
 }
diff --git a/kitchensync/libqopensync/syncupdates.cpp b/kitchensync/libqopensync/syncupdates.cpp
index 653ccf7f3..3ad273f9f 100644
--- a/kitchensync/libqopensync/syncupdates.cpp
+++ b/kitchensync/libqopensync/syncupdates.cpp
@@ -19,7 +19,8 @@
     Boston, MA 02110-1301, USA.
 */
 
-#include <osengine/engine.h>
+#include <opensync/opensync.h>
+#include <opensync/opensync-engine.h>
 
 #include "syncupdates.h"
 
@@ -32,32 +33,26 @@ SyncMemberUpdate::SyncMemberUpdate()
 SyncMemberUpdate::SyncMemberUpdate( OSyncMemberUpdate *update )
 {
   switch ( update->type ) {
-    case MEMBER_CONNECTED:
+    case OSYNC_CLIENT_EVENT_CONNECTED:
       mType = Connected;
       break;
-    case MEMBER_SENT_CHANGES:
-      mType = SentChanges;
-      break;
-    case MEMBER_COMMITTED_ALL:
-      mType = CommittedAll;
-      break;
-    case MEMBER_DISCONNECTED:
+    case OSYNC_CLIENT_EVENT_DISCONNECTED:
       mType = Disconnected;
       break;
-    case MEMBER_CONNECT_ERROR:
-      mType = ConnectError;
+    case OSYNC_CLIENT_EVENT_READ:
+      mType = Read; 
       break;
-    case MEMBER_GET_CHANGES_ERROR:
-      mType = GetChangesError;
+    case OSYNC_CLIENT_EVENT_WRITTEN:
+      mType = Written;
       break;
-    case MEMBER_COMMITTED_ALL_ERROR:
-      mType = CommittedAllError;
+    case OSYNC_CLIENT_EVENT_SYNC_DONE:
+      mType = SyncDone;
       break;
-    case MEMBER_SYNC_DONE_ERROR:
-      mType = SyncDoneError;
+    case OSYNC_CLIENT_EVENT_DISCOVERED:
+      mType = Discovered;
       break;
-    case MEMBER_DISCONNECT_ERROR:
-      mType = DisconnectedError;
+    case OSYNC_CLIENT_EVENT_ERROR:
+      mType = Error;
       break;
   }
 
@@ -94,20 +89,14 @@ SyncChangeUpdate::SyncChangeUpdate()
 SyncChangeUpdate::SyncChangeUpdate( OSyncChangeUpdate *update )
 {
   switch ( update->type ) {
-    case CHANGE_RECEIVED:
-      mType = Received;
-      break;
-    case CHANGE_RECEIVED_INFO:
-      mType = ReceivedInfo;
+    case OSYNC_CHANGE_EVENT_READ:
+      mType = Read;
       break;
-    case CHANGE_SENT:
-      mType = Sent;
+    case OSYNC_CHANGE_EVENT_WRITTEN:
+      mType = Written;
       break;
-    case CHANGE_WRITE_ERROR:
-      mType = WriteError;
-      break;
-    case CHANGE_RECV_ERROR:
-      mType = ReceiveError;
+    case OSYNC_CHANGE_EVENT_ERROR:
+      mType = Error;
       break;
   }
 
@@ -115,7 +104,7 @@ SyncChangeUpdate::SyncChangeUpdate( OSyncChangeUpdate *update )
     mResult = Result( &(update->error) );
 
   mChange = SyncChange( update->change );
-  mMemberId = update->member_id;
+  mMember.mMember = update->member;
   mMappingId = update->mapping_id;
 }
 
@@ -138,9 +127,9 @@ SyncChange SyncChangeUpdate::change() const
   return mChange;
 }
 
-int SyncChangeUpdate::memberId() const
+Member SyncChangeUpdate::member() const
 {
-  return mMemberId;
+  return mMember;
 }
 
 int SyncChangeUpdate::mappingId() const
@@ -155,14 +144,14 @@ SyncMappingUpdate::SyncMappingUpdate()
 SyncMappingUpdate::SyncMappingUpdate( OSyncMappingUpdate *update, OSyncEngine *engine )
 {
   switch ( update->type ) {
-    case MAPPING_SOLVED:
+    case OSYNC_MAPPING_EVENT_SOLVED:
       mType = Solved;
       break;
-    case MAPPING_SYNCED:
-      mType = Synced;
-      break;
-    case MAPPING_WRITE_ERROR:
-      mType = WriteError;
+//    case OSYNC_MAPPING_EVENT_SYNCED:
+  //    mType = Synced;
+    //  break;
+    case OSYNC_MAPPING_EVENT_ERROR:
+      mType = Error;
       break;
   }
 
@@ -171,7 +160,9 @@ SyncMappingUpdate::SyncMappingUpdate( OSyncMappingUpdate *update, OSyncEngine *e
 
   mWinner = update->winner;
   mMapping.mEngine = engine;
-  mMapping.mMapping = update->mapping;
+
+  // TODO PORTING
+//  mMapping.mMapping = update->mapping;
 }
 
 SyncMappingUpdate::~SyncMappingUpdate()
@@ -205,30 +196,33 @@ SyncEngineUpdate::SyncEngineUpdate()
 SyncEngineUpdate::SyncEngineUpdate( OSyncEngineUpdate *update )
 {
   switch ( update->type ) {
-    case ENG_ENDPHASE_CON:
-      mType = EndPhaseConnected;
+    case OSYNC_ENGINE_EVENT_CONNECTED:
+      mType = Connected;
       break;
-    case ENG_ENDPHASE_READ:
-      mType = EndPhaseRead;
+    case OSYNC_ENGINE_EVENT_READ:
+      mType = Read;
       break;
-    case ENG_ENDPHASE_WRITE:
-      mType = EndPhaseWrite;
+    case OSYNC_ENGINE_EVENT_WRITTEN:
+      mType = Written;
       break;
-    case ENG_ENDPHASE_DISCON:
-      mType = EndPhaseDisconnected;
+    case OSYNC_ENGINE_EVENT_DISCONNECTED: 
+      mType = Disconnected;
       break;
-    case ENG_ERROR:
+    case OSYNC_ENGINE_EVENT_ERROR:
       mType = Error;
       break;
-    case ENG_SYNC_SUCCESSFULL:
-      mType = SyncSuccessfull;
+    case OSYNC_ENGINE_EVENT_SUCCESSFUL:
+      mType = SyncSuccessful;
       break;
-    case ENG_PREV_UNCLEAN:
+    case OSYNC_ENGINE_EVENT_PREV_UNCLEAN:
       mType = PrevUnclean;
       break;
-    case ENG_END_CONFLICTS:
+    case OSYNC_ENGINE_EVENT_END_CONFLICTS:
       mType = EndConflicts;
       break;
+    case OSYNC_ENGINE_EVENT_SYNC_DONE:
+      mType = SyncDone;
+      break;
   }
 
   if ( update->error )
diff --git a/kitchensync/libqopensync/syncupdates.h b/kitchensync/libqopensync/syncupdates.h
index 14a2d9193..96741b059 100644
--- a/kitchensync/libqopensync/syncupdates.h
+++ b/kitchensync/libqopensync/syncupdates.h
@@ -42,14 +42,12 @@ class SyncMemberUpdate
   public:
     enum Type {
       Connected,
-      SentChanges,
-      CommittedAll,
       Disconnected,
-      ConnectError,
-      GetChangesError,
-      CommittedAllError,
-      SyncDoneError,
-      DisconnectedError
+      Read,
+      Written,
+      SyncDone,
+      Discovered,
+      Error
     };
 
     SyncMemberUpdate();
@@ -72,11 +70,9 @@ class SyncChangeUpdate
 
   public:
     enum Type {
-      Received = 1,
-      ReceivedInfo,
-      Sent,
-      WriteError,
-      ReceiveError
+      Read = 1,
+      Written,
+      Error
     };
 
     SyncChangeUpdate();
@@ -86,14 +82,14 @@ class SyncChangeUpdate
     Type type() const;
     Result result() const;
     SyncChange change() const;
-    int memberId() const;
+    Member member() const;
     int mappingId() const;
 
   private:
     Type mType;
     Result mResult;
     SyncChange mChange;
-    int mMemberId;
+    Member mMember;
     int mMappingId;
 };
 
@@ -104,8 +100,8 @@ class SyncMappingUpdate
   public:
     enum Type {
       Solved = 1,
-      Synced,
-      WriteError
+      //Synced,
+      Error
     };
 
     SyncMappingUpdate();
@@ -130,14 +126,15 @@ class SyncEngineUpdate
 
   public:
     enum Type {
-      EndPhaseConnected = 1,
-      EndPhaseRead,
-      EndPhaseWrite,
-      EndPhaseDisconnected,
+      Connected = 1,
+      Read,
+      Written,
+      Disconnected,
       Error,
-      SyncSuccessfull,
+      SyncSuccessful,
       PrevUnclean,
-      EndConflicts
+      EndConflicts,
+      SyncDone
     };
 
     SyncEngineUpdate();
diff --git a/kitchensync/src/Makefile.am b/kitchensync/src/Makefile.am
index 7f94fc173..6527084cc 100644
--- a/kitchensync/src/Makefile.am
+++ b/kitchensync/src/Makefile.am
@@ -24,7 +24,7 @@ libkitchensync_la_SOURCES = aboutpage.cpp mainwidget.cpp groupconfigdialog.cpp \
                             pluginpicker.cpp configgui.cpp configguiblank.cpp configguifile.cpp \
                             memberinfo.cpp groupconfigcommon.cpp kwidgetlist.cpp \
                             configguipalm.cpp conflictdialog.cpp singleconflictdialog.cpp \
-                            addresseediffalgo.cpp calendardiffalgo.cpp \
+                            addresseediffalgo.cpp calendardiffalgo.cpp xmldiffalgo.cpp \
                             htmldiffalgodisplay.cpp genericdiffalgo.cpp multiconflictdialog.cpp \
                             configguiirmc.cpp \
                             configguisyncmlobex.cpp configguisyncmlhttp.cpp configguiopie.cpp  \
diff --git a/kitchensync/src/configguifile.cpp b/kitchensync/src/configguifile.cpp
index 6a8b0402c..a0c6a596d 100644
--- a/kitchensync/src/configguifile.cpp
+++ b/kitchensync/src/configguifile.cpp
@@ -55,13 +55,20 @@ void ConfigGuiFile::load( const TQString &xml )
   TQDomDocument doc;
   doc.setContent( xml );
   TQDomElement docElement = doc.documentElement();
-  TQDomNode n;
-  for( n = docElement.firstChild(); !n.isNull(); n = n.nextSibling() ) {
-    TQDomElement e = n.toElement();
-    if ( e.tagName() == "path" ) {
-      mFilename->setURL( e.text() );
-    } else if ( e.tagName() == "recursive" ) {
-      mRecursive->setChecked( e.text() == "TRUE" );
+
+  TQDomNode node;
+  for ( node = docElement.firstChild(); !node.isNull(); node = node.nextSibling() ) {
+    TQDomElement e = node.toElement();
+    if ( e.tagName() == "directory" ) {
+      TQDomNode subNode;
+      for ( subNode = e.firstChild(); !subNode.isNull(); subNode = subNode.nextSibling() ) {
+        TQDomElement subElement = subNode.toElement();
+        if ( subElement.tagName() == "path" ) {
+          mFilename->setURL( subElement.text() );
+        } else if ( subElement.tagName() == "recursive" ) {
+          mRecursive->setChecked( subElement.text() == "TRUE" );
+        }
+      }
     }
   }
 }
@@ -69,13 +76,18 @@ void ConfigGuiFile::load( const TQString &xml )
 TQString ConfigGuiFile::save() const
 {
   TQString xml;
-  xml = "<config>";
-  xml += "<path>" + mFilename->url() + "</path>";
-  xml += "<recursive>";
-  if ( mRecursive->isChecked() ) xml += "TRUE";
-  else xml += "FALSE";
-  xml += "</recursive>";
-  xml += "</config>";
+  xml = "<config>\n";
+  xml += "  <directory>\n";
+  xml += "    <path>" + mFilename->url() + "</path>\n";
+  xml += "    <objtype>data</objtype>\n";
+  xml += "    <recursive>";
+  if ( mRecursive->isChecked() )
+    xml += "TRUE";
+  else
+    xml += "FALSE";
+  xml += "</recursive>\n";
+  xml += "  </directory>\n";
+  xml += "</config>\n";
 
   return xml;
 }
diff --git a/kitchensync/src/configguisyncmlhttp.cpp b/kitchensync/src/configguisyncmlhttp.cpp
index 26a8c2241..b07111675 100644
--- a/kitchensync/src/configguisyncmlhttp.cpp
+++ b/kitchensync/src/configguisyncmlhttp.cpp
@@ -121,7 +121,7 @@ ConfigGuiSyncmlHttp::ConfigGuiSyncmlHttp( const QSync::Member &member, TQWidget
   mGridLayout->addWidget( label, 5, 0 );
 
   mRecvLimit = new TQSpinBox( optionWidget );
-  mRecvLimit->setMinValue( 1 );
+  mRecvLimit->setMinValue( 0 );
   mRecvLimit->setMaxValue( 65536 );
   mGridLayout->addWidget( mRecvLimit, 5, 1 );
 
@@ -130,7 +130,7 @@ ConfigGuiSyncmlHttp::ConfigGuiSyncmlHttp( const QSync::Member &member, TQWidget
   mGridLayout->addWidget( label, 6, 0 );
 
   mMaxObjSize = new TQSpinBox( optionWidget );
-  mMaxObjSize->setMinValue( 1 );
+  mMaxObjSize->setMinValue( 0 );
   mMaxObjSize->setMaxValue( 65536 );
   mGridLayout->addWidget( mMaxObjSize, 6, 1 );
 
diff --git a/kitchensync/src/configguisyncmlobex.cpp b/kitchensync/src/configguisyncmlobex.cpp
index 372cf9261..ea952ef4a 100644
--- a/kitchensync/src/configguisyncmlobex.cpp
+++ b/kitchensync/src/configguisyncmlobex.cpp
@@ -153,7 +153,7 @@ ConfigGuiSyncmlObex::ConfigGuiSyncmlObex( const QSync::Member &member, TQWidget
   mGridLayout->addWidget( label, 14, 0 );
 
   mRecvLimit = new TQSpinBox( optionsWidget );
-  mRecvLimit->setMinValue( 1 );
+  mRecvLimit->setMinValue( 0 );
   mRecvLimit->setMaxValue( 65536 );
   mGridLayout->addWidget( mRecvLimit, 14, 1 );
 
@@ -162,7 +162,7 @@ ConfigGuiSyncmlObex::ConfigGuiSyncmlObex( const QSync::Member &member, TQWidget
   mGridLayout->addWidget( label, 15, 0 );
 
   mMaxObjSize = new TQSpinBox( optionsWidget );
-  mMaxObjSize->setMinValue( 1 );
+  mMaxObjSize->setMinValue( 0 );
   mMaxObjSize->setMaxValue( 65536 );
   mGridLayout->addWidget( mMaxObjSize, 15, 1 );
 
diff --git a/kitchensync/src/groupconfig.cpp b/kitchensync/src/groupconfig.cpp
index cfedcbfad..7e0af734a 100644
--- a/kitchensync/src/groupconfig.cpp
+++ b/kitchensync/src/groupconfig.cpp
@@ -27,8 +27,10 @@
 #include "syncprocess.h"
 #include "syncprocessmanager.h"
 
+#include <libqopensync/engine.h>
 #include <libqopensync/group.h>
 #include <libqopensync/plugin.h>
+#include <libqopensync/result.h>
 
 #include <kdialog.h>
 #include <kiconloader.h>
@@ -40,6 +42,7 @@
 #include <tqlabel.h>
 #include <tqlayout.h>
 #include <tqpushbutton.h>
+#include <tqtimer.h>
 
 GroupConfig::GroupConfig( TQWidget *parent )
   : TQWidget( parent )
@@ -84,14 +87,6 @@ GroupConfig::GroupConfig( TQWidget *parent )
   mMemberView = new KJanusWidget( this, 0, KJanusWidget::IconList );
   topLayout->addWidget( mMemberView );
 
-  TQBoxLayout *buttonLayout = new TQHBoxLayout( topLayout );
-
-  TQPushButton *addButton = new TQPushButton( i18n("Add Member..."), this );
-  connect( addButton, TQT_SIGNAL( clicked() ), TQT_SLOT( addMember() ) );
-  buttonLayout->addWidget( addButton );
-
-  buttonLayout->addStretch( 1 );
-
   icon = KGlobal::iconLoader()->loadIcon( "bookmark", KIcon::Desktop );
   TQFrame *page = mMemberView->addPage( i18n("Group"),
     i18n("General Group Settings"), icon );
@@ -99,6 +94,8 @@ GroupConfig::GroupConfig( TQWidget *parent )
 
   mCommonConfig = new GroupConfigCommon( page );
   pageLayout->addWidget( mCommonConfig );
+
+  connect( mMemberView, TQT_SIGNAL( aboutToShowPage( TQWidget* ) ), TQT_SLOT( memberWidgetSelected( TQWidget* ) ) );
 }
 
 void GroupConfig::setSyncProcess( SyncProcess *process )
@@ -113,9 +110,9 @@ void GroupConfig::setSyncProcess( SyncProcess *process )
 
 void GroupConfig::updateMembers()
 {
-  TQValueList<MemberConfig *>::ConstIterator memberIt;
+  TQMap<TQWidget*, MemberConfig *>::ConstIterator memberIt;
   for ( memberIt = mMemberConfigs.begin(); memberIt != mMemberConfigs.end(); ++memberIt )
-    (*memberIt)->saveData();
+    memberIt.data()->saveData();
 
   TQValueList<TQFrame *>::ConstIterator it2;
   for ( it2 = mConfigPages.begin(); it2 != mConfigPages.end(); ++it2 ) {
@@ -125,10 +122,9 @@ void GroupConfig::updateMembers()
   mConfigPages.clear();
   mMemberConfigs.clear();
 
-  QSync::Group group = mProcess->group();
-  QSync::Group::Iterator it( group.begin() );
-  for ( ; it != group.end(); ++it ) {
-    QSync::Member member = *it;
+  const QSync::Group group = mProcess->group();
+  for ( int i = 0; i < group.memberCount(); ++i ) {
+    QSync::Member member = group.memberAt( i );
     MemberInfo mi( member );
     TQFrame *page = mMemberView->addPage( mi.name(), 
       TQString( "%1 (%2)" ).arg( mi.name() ).arg(member.pluginName()), mi.desktopIcon() );
@@ -137,7 +133,7 @@ void GroupConfig::updateMembers()
     mConfigPages.append( page );
 
     MemberConfig *memberConfig = new MemberConfig( page, member );
-    mMemberConfigs.append( memberConfig );
+    mMemberConfigs.insert( page, memberConfig );
     pageLayout->addWidget( memberConfig );
 
     memberConfig->loadData();
@@ -148,15 +144,30 @@ void GroupConfig::saveConfig()
 {
   mProcess->group().save();
 
-  TQValueList<MemberConfig *>::ConstIterator it;
+  TQMap<TQWidget*, MemberConfig*>::ConstIterator it;
   for ( it = mMemberConfigs.begin(); it != mMemberConfigs.end(); ++it )
-    (*it)->saveData();
+    it.data()->saveData();
 
   mCommonConfig->save();
 
+  const QSync::Group group = mProcess->group();
+  for ( int i = 0; i < group.memberCount(); ++i ) {
+    const QSync::Member member = group.memberAt( i );
+    mProcess->engine()->discover( member );
+  }
+
   mProcess->reinitEngine();
 }
 
+void GroupConfig::memberWidgetSelected( TQWidget *wdg )
+{
+  /**
+   * Emit 'true' whenever a real member widget is selected by the
+   * user.
+   */
+  emit memberSelected( wdg != mCommonConfig->parentWidget() );
+}
+
 void GroupConfig::addMember()
 {
   QSync::Plugin plugin = PluginPickerDialog::getPlugin( this );
@@ -176,4 +187,17 @@ void GroupConfig::addMember()
   }
 }
 
+void GroupConfig::removeMember()
+{
+  TQWidget *selectedWidget = mMemberView->pageWidget( mMemberView->activePageIndex() );
+  if ( selectedWidget && mMemberConfigs.contains( selectedWidget ) ) {
+    MemberConfig *config = mMemberConfigs[ selectedWidget ];
+
+    SyncProcessManager::self()->removeMember( mProcess, config->member() );
+    mMemberConfigs.remove( selectedWidget );
+
+    TQTimer::singleShot( 0, this, TQT_SLOT( updateMembers() ) );
+  }
+}
+
 #include "groupconfig.moc"
diff --git a/kitchensync/src/groupconfig.h b/kitchensync/src/groupconfig.h
index 8dc300b6b..4deb8f255 100644
--- a/kitchensync/src/groupconfig.h
+++ b/kitchensync/src/groupconfig.h
@@ -40,12 +40,19 @@ class GroupConfig : public QWidget
 
     void setSyncProcess( SyncProcess *process );
 
+    void saveConfig();
+
+  public slots:
+    void addMember();
+    void removeMember();
+
     void updateMembers();
 
-    void saveConfig();
+  signals:
+    void memberSelected( bool );
 
   protected slots:
-    void addMember();
+    void memberWidgetSelected( TQWidget* );
 
   private:
     TQLabel *mNameLabel;
@@ -55,8 +62,8 @@ class GroupConfig : public QWidget
     SyncProcess *mProcess;
 
     GroupConfigCommon *mCommonConfig;
-    TQValueList<MemberConfig *> mMemberConfigs;
-    TQValueList<TQFrame *> mConfigPages;
+    TQMap<TQWidget*, MemberConfig*> mMemberConfigs;
+    TQValueList<TQFrame*> mConfigPages;
 };
 
 #endif
diff --git a/kitchensync/src/groupconfigcommon.cpp b/kitchensync/src/groupconfigcommon.cpp
index 9f629c4d2..360746893 100644
--- a/kitchensync/src/groupconfigcommon.cpp
+++ b/kitchensync/src/groupconfigcommon.cpp
@@ -30,14 +30,15 @@
 #include <tqcheckbox.h>
 
 #include <libqopensync/group.h>
-#include <libqopensync/conversion.h>
-#include <libqopensync/environment.h>
+//#include <libqopensync/conversion.h>
 
 #include "syncprocess.h"
 #include "syncprocessmanager.h"
 
 #include "groupconfigcommon.h"
 
+// TODO: port ObjectTypeSelector to ported solution of Conversation class
+#if 0
 ObjectTypeSelector::ObjectTypeSelector( TQWidget *parent )
   : TQWidget( parent )
 {
@@ -124,6 +125,7 @@ void ObjectTypeSelector::save( QSync::Group group )
   QSync::GroupConfig config = group.config();
   config.setActiveObjectTypes( objectTypes );
 }
+#endif
 
 GroupConfigCommon::GroupConfigCommon( TQWidget *parent )
   : TQWidget( parent )
@@ -135,10 +137,11 @@ GroupConfigCommon::GroupConfigCommon( TQWidget *parent )
   mGroupName = new KLineEdit( this );
   layout->addWidget( mGroupName, 0, 1 );
 
-  layout->addWidget( new TQLabel( i18n( "Object Types to be Synchronized:"), this ), 1, 0, Qt::AlignTop );
+  //layout->addWidget( new TQLabel( i18n( "Object Types to be Synchronized:"), this ), 1, 0, Qt::AlignTop );
 
-  mObjectTypeSelector = new ObjectTypeSelector( this );
-  layout->addWidget( mObjectTypeSelector, 1, 1 );
+  // TODO port ObjectTypeSelector class..
+  //mObjectTypeSelector = new ObjectTypeSelector( this );
+  //layout->addWidget( mObjectTypeSelector, 1, 1 );
 
   layout->setRowStretch( 2, 1 );
 }
@@ -148,11 +151,15 @@ void GroupConfigCommon::setSyncProcess( SyncProcess *syncProcess )
   mSyncProcess = syncProcess;
 
   mGroupName->setText( mSyncProcess->group().name() );
-  mObjectTypeSelector->load( mSyncProcess->group() );
+
+  // TODO port ObjectTypeSelector class..
+  //mObjectTypeSelector->load( mSyncProcess->group() );
 }
 
 void GroupConfigCommon::save()
 {
   mSyncProcess->group().setName( mGroupName->text() );
-  mObjectTypeSelector->save( mSyncProcess->group() );
+
+  // TODO port ObjectTypeSelector class..
+  //mObjectTypeSelector->save( mSyncProcess->group() );
 }
diff --git a/kitchensync/src/groupconfigcommon.h b/kitchensync/src/groupconfigcommon.h
index a953607fe..15ec5e5ab 100644
--- a/kitchensync/src/groupconfigcommon.h
+++ b/kitchensync/src/groupconfigcommon.h
@@ -30,7 +30,9 @@ class KLineEdit;
 class SyncProcess;
 class TQCheckBox;
 
-class ObjectTypeSelector : public QWidget
+//TODO: Conversation needs to be ported before...
+#if 0
+class ObjectTypeSelector : public TQWidget
 {
   public:
     ObjectTypeSelector( TQWidget *parent );
@@ -41,6 +43,7 @@ class ObjectTypeSelector : public QWidget
   private:
     TQMap<TQString,TQCheckBox *> mObjectTypeChecks;
 };
+#endif
 
 class GroupConfigCommon : public QWidget
 {
@@ -52,7 +55,7 @@ class GroupConfigCommon : public QWidget
 
   private:
     KLineEdit *mGroupName;
-    ObjectTypeSelector *mObjectTypeSelector;
+  //  ObjectTypeSelector *mObjectTypeSelector;
 
     SyncProcess *mSyncProcess;
 };
diff --git a/kitchensync/src/groupconfigdialog.cpp b/kitchensync/src/groupconfigdialog.cpp
index 4d8be65d0..d0b5894f9 100644
--- a/kitchensync/src/groupconfigdialog.cpp
+++ b/kitchensync/src/groupconfigdialog.cpp
@@ -28,7 +28,7 @@
 
 GroupConfigDialog::GroupConfigDialog( TQWidget *parent, SyncProcess *process )
   : KDialogBase( parent, 0, true, i18n("Configure Synchronization Group"),
-     Ok )
+     Ok | User1 | User2, Ok )
 {
   TQFrame *topFrame = makeMainWidget();
 
@@ -40,6 +40,13 @@ GroupConfigDialog::GroupConfigDialog( TQWidget *parent, SyncProcess *process )
   mConfigWidget->setSyncProcess( process );
 
   setInitialSize( configDialogSize( "size_groupconfigdialog" ) );
+
+  enableButton( User1, false );
+  setButtonText( User1, i18n( "Remove Member" ) );
+
+  connect( mConfigWidget, TQT_SIGNAL( memberSelected( bool ) ), TQT_SLOT( memberSelected( bool ) ) );
+
+  setButtonText( User2, i18n("Add Member...") );
 }
 
 GroupConfigDialog::~GroupConfigDialog()
@@ -54,4 +61,19 @@ void GroupConfigDialog::slotOk()
   accept();
 }
 
+void GroupConfigDialog::slotUser1()
+{
+  mConfigWidget->removeMember();
+}
+
+void GroupConfigDialog::slotUser2()
+{
+  mConfigWidget->addMember();
+}
+
+void GroupConfigDialog::memberSelected( bool selected )
+{
+  enableButton( User1, selected );
+}
+
 #include "groupconfigdialog.moc"
diff --git a/kitchensync/src/groupconfigdialog.h b/kitchensync/src/groupconfigdialog.h
index 5fd70884f..8dde4da77 100644
--- a/kitchensync/src/groupconfigdialog.h
+++ b/kitchensync/src/groupconfigdialog.h
@@ -35,6 +35,11 @@ class GroupConfigDialog : public KDialogBase
 
   protected slots:
     void slotOk();
+    void slotUser1();
+    void slotUser2();
+
+  private slots:
+    void memberSelected( bool );
 
   private:
     GroupConfig *mConfigWidget;
diff --git a/kitchensync/src/groupitem.cpp b/kitchensync/src/groupitem.cpp
index 784991c6f..fe4b2fdcd 100644
--- a/kitchensync/src/groupitem.cpp
+++ b/kitchensync/src/groupitem.cpp
@@ -33,6 +33,9 @@
 #include <tqprogressbar.h>
 #include <tqvbox.h>
 
+#include <libqopensync/plugin.h>
+#include <libqopensync/pluginenv.h>
+
 #include "memberinfo.h"
 #include "multiconflictdialog.h"
 #include "singleconflictdialog.h"
@@ -150,12 +153,9 @@ void GroupItem::update()
   mProgressBar->reset();
   mProgressBar->hide();
 
-  QSync::Group group = mSyncProcess->group();
-  QSync::Group::Iterator memberIt( group.begin() );
-  QSync::Group::Iterator memberEndIt( group.end() );
-
-  for ( ; memberIt != memberEndIt; ++memberIt ) {
-    MemberItem *item = new MemberItem( mBox, mSyncProcess, *memberIt );
+  const QSync::Group group = mSyncProcess->group();
+  for ( int i = 0; i < group.memberCount(); ++i ) {
+    MemberItem *item = new MemberItem( mBox, mSyncProcess, group.memberAt( i ) );
     item->show();
     item->setStatusMessage( i18n( "Ready" ) );
     mMemberItems.append( item );
@@ -187,14 +187,11 @@ void GroupItem::conflict( QSync::SyncMapping mapping )
 void GroupItem::change( const QSync::SyncChangeUpdate &update )
 {
   switch ( update.type() ) {
-    case QSync::SyncChangeUpdate::Received:
+    case QSync::SyncChangeUpdate::Read:
       mProcessedItems++;
       mStatus->setText( i18n( "%1 entries read" ).arg( mProcessedItems ) );
       break;
-    case QSync::SyncChangeUpdate::ReceivedInfo:
-      mStatus->setText( i18n( "Receive information" ) );
-      break;
-    case QSync::SyncChangeUpdate::Sent:
+    case QSync::SyncChangeUpdate::Written:
       mProcessedItems--;
       mStatus->setText( i18n( "%1 entries written" ).arg( mMaxProcessedItems - mProcessedItems ) );
 
@@ -211,11 +208,7 @@ void GroupItem::change( const QSync::SyncChangeUpdate &update )
         mProgressBar->setProgress( 100 - progress );
       }
       break;
-    case QSync::SyncChangeUpdate::WriteError:
-      mStatus->setText( i18n( "Error" ) );
-      KPassivePopup::message( update.result().message(), this );
-      break;
-    case QSync::SyncChangeUpdate::ReceiveError:
+    case QSync::SyncChangeUpdate::Error:
       mStatus->setText( i18n( "Error" ) );
       KPassivePopup::message( update.result().message(), this );
       break;
@@ -232,21 +225,21 @@ void GroupItem::mapping( const QSync::SyncMappingUpdate& )
 void GroupItem::engine( const QSync::SyncEngineUpdate &update )
 {
   switch ( update.type() ) {
-    case QSync::SyncEngineUpdate::EndPhaseConnected:
+    case QSync::SyncEngineUpdate::Connected:
       mStatus->setText( i18n( "Connected" ) );
       mProgressBar->setProgress( 0 );
       mSynchronizing = true;
       mSyncAction->setText( "Abort Synchronization" );
       break;
-    case QSync::SyncEngineUpdate::EndPhaseRead:
+    case QSync::SyncEngineUpdate::Read:
       mStatus->setText( i18n( "Data read" ) );
       break;
-    case QSync::SyncEngineUpdate::EndPhaseWrite:
+    case QSync::SyncEngineUpdate::Written:
       mStatus->setText( i18n( "Data written" ) );
       mProgressBar->setProgress( 100 );
       mProcessedItems = mMaxProcessedItems = 0;
       break;
-    case QSync::SyncEngineUpdate::EndPhaseDisconnected:
+    case QSync::SyncEngineUpdate::Disconnected:
       mStatus->setText( i18n( "Disconnected" ) );
       break;
     case QSync::SyncEngineUpdate::Error:
@@ -257,7 +250,7 @@ void GroupItem::engine( const QSync::SyncEngineUpdate &update )
       mSynchronizing = false;
       mSyncAction->setText( i18n( "Synchronize Now" ) );
       break;
-    case QSync::SyncEngineUpdate::SyncSuccessfull:
+    case QSync::SyncEngineUpdate::SyncSuccessful:
       mStatus->setText( i18n( "Successfully synchronized" ) );
       mSyncProcess->group().setLastSynchronization( TQDateTime::currentDateTime() );
       mSyncProcess->group().save();
@@ -288,28 +281,22 @@ void GroupItem::member( const QSync::SyncMemberUpdate &update )
         case QSync::SyncMemberUpdate::Connected:
           (*it)->setStatusMessage( i18n( "Connected" ) );
           break;
-        case QSync::SyncMemberUpdate::SentChanges:
+        case QSync::SyncMemberUpdate::Read:
           (*it)->setStatusMessage( i18n( "Changes read" ) );
           break;
-        case QSync::SyncMemberUpdate::CommittedAll:
+        case QSync::SyncMemberUpdate::Written:
           (*it)->setStatusMessage( i18n( "Changes written" ) );
           break;
         case QSync::SyncMemberUpdate::Disconnected:
           (*it)->setStatusMessage( i18n( "Disconnected" ) );
           break;
-        case QSync::SyncMemberUpdate::ConnectError:
-          (*it)->setStatusMessage( i18n( "Error: %1" ).arg( update.result().message() ) );
+        case QSync::SyncMemberUpdate::SyncDone:
+          (*it)->setStatusMessage( i18n( "Synchronization done" ) );
           break;
-        case QSync::SyncMemberUpdate::GetChangesError:
-          (*it)->setStatusMessage( i18n( "Error: %1" ).arg( update.result().message() ) );
+        case QSync::SyncMemberUpdate::Discovered:
+          (*it)->setStatusMessage( i18n( "Discovered" ) );
           break;
-        case QSync::SyncMemberUpdate::CommittedAllError:
-          (*it)->setStatusMessage( i18n( "Error: %1" ).arg( update.result().message() ) );
-          break;
-        case QSync::SyncMemberUpdate::SyncDoneError:
-          (*it)->setStatusMessage( i18n( "Error: %1" ).arg( update.result().message() ) );
-          break;
-        case QSync::SyncMemberUpdate::DisconnectedError:
+        case QSync::SyncMemberUpdate::Error:
           (*it)->setStatusMessage( i18n( "Error: %1" ).arg( update.result().message() ) );
           break;
         default:
@@ -352,11 +339,8 @@ MemberItem::MemberItem( TQWidget *parent, SyncProcess *process,
   TQFont boldFont;
   boldFont.setBold( true );
 
-  MemberInfo mi( member );
-
-  TQPixmap icon = mi.smallIcon();
-
-  QSync::Plugin plugin = member.plugin();
+  const MemberInfo mi( member );
+  const TQPixmap icon = mi.smallIcon();
 
   TQVBoxLayout *layout = new TQVBoxLayout( this );
 
@@ -378,7 +362,14 @@ MemberItem::MemberItem( TQWidget *parent, SyncProcess *process,
   mStatus = new TQLabel( box );
 
   mMemberName->setText( member.name() );
-  mDescription->setText( plugin.longName() );
+
+  const QSync::PluginEnv *env = SyncProcessManager::self()->pluginEnv();
+  const QSync::Plugin plugin = env->pluginByName( member.pluginName() );
+
+  if ( plugin.isValid() )
+    mDescription->setText( plugin.longName() );
+  else
+    mDescription->setText( i18n("Plugin \"%1\" can't get initialized!").arg( member.pluginName() ) );
 }
 
 void MemberItem::setStatusMessage( const TQString &msg )
diff --git a/kitchensync/src/mainwidget.cpp b/kitchensync/src/mainwidget.cpp
index d04542f9d..02b279b3e 100644
--- a/kitchensync/src/mainwidget.cpp
+++ b/kitchensync/src/mainwidget.cpp
@@ -26,7 +26,7 @@
 #include "syncprocess.h"
 #include "syncprocessmanager.h"
 
-#include <libqopensync/environment.h>
+#include <libqopensync/result.h>
 
 #include <kaboutdata.h>
 #include <kaction.h>
@@ -46,13 +46,6 @@ MainWidget::MainWidget( KXMLGUIClient *guiClient, TQWidget *widget, const char *
   initGUI();
   initActions();
 
-  /** apply object type filter hack **/
-  int count = SyncProcessManager::self()->count();
-  for ( int i = 0; i < count; ++i ) {
-    SyncProcessManager::self()->at( i )->applyObjectTypeFilter();
-  }
-  /** apply object type filter hack **/
-
   mGroupView->updateView();
 
   connect( SyncProcessManager::self(), TQT_SIGNAL( changed() ),
@@ -125,12 +118,19 @@ void MainWidget::addGroup()
 {
   bool ok;
   TQString name = KInputDialog::getText( i18n("Create Synchronization Group"),
-    i18n("Name for new synchronization group."), TQString::null, &ok, this );
+    i18n("Name for new synchronization group."), i18n( "Default" ), &ok, this );
   if ( ok ) {
+    SyncProcess *process = SyncProcessManager::self()->byGroupName( name );
+    if ( process ) {
+      KMessageBox::error( this, i18n( "A group with the same name exists already.\nPlease choose another name." ),
+                          i18n( "Duplicated Group Name" ) );
+      return;
+    }
+
     SyncProcessManager::self()->addGroup( name );
     enableActions();
 
-    SyncProcess *process = SyncProcessManager::self()->byGroupName( name );
+    process = SyncProcessManager::self()->byGroupName( name );
     if ( process )
       editGroup( process );
   }
diff --git a/kitchensync/src/memberconfig.cpp b/kitchensync/src/memberconfig.cpp
index 37755a504..d3d08a63b 100644
--- a/kitchensync/src/memberconfig.cpp
+++ b/kitchensync/src/memberconfig.cpp
@@ -23,6 +23,8 @@
 #include "configgui.h"
 #include "memberinfo.h"
 
+#include <libqopensync/result.h>
+
 #include <klocale.h>
 #include <kmessagebox.h>
 
@@ -67,13 +69,16 @@ void MemberConfig::saveData()
   if ( txt.isEmpty() ) {
     KMessageBox::sorry( this, i18n("Configuration of %1 is empty.").arg( mMember.pluginName() ) );
   } else {
-    TQByteArray cfg = txt.utf8();
-    cfg.truncate(cfg.size() - 1); /* discard NUL terminator */
-    mMember.setConfiguration( cfg );
+    mMember.setConfiguration( txt.utf8() );
     mMember.setName( mGui->instanceName() );
     // TODO: Check for save() error.
     mMember.save();
   }
 }
 
+QSync::Member MemberConfig::member() const
+{
+  return mMember;
+}
+
 #include "memberconfig.moc"
diff --git a/kitchensync/src/memberconfig.h b/kitchensync/src/memberconfig.h
index c6457972d..b2a3569d4 100644
--- a/kitchensync/src/memberconfig.h
+++ b/kitchensync/src/memberconfig.h
@@ -38,6 +38,8 @@ class MemberConfig : public QWidget
     void loadData();
     void saveData();
 
+    QSync::Member member() const;
+
   private:
     QSync::Member mMember;
 
diff --git a/kitchensync/src/multiconflictdialog.cpp b/kitchensync/src/multiconflictdialog.cpp
index 7d7805c42..88d42d3b3 100644
--- a/kitchensync/src/multiconflictdialog.cpp
+++ b/kitchensync/src/multiconflictdialog.cpp
@@ -39,8 +39,10 @@ class ChangeItem : public KWidgetListItem
     {
       TQGridLayout *layout = new TQGridLayout( this, 2, 1, KDialog::marginHint(), KDialog::spacingHint() );
 
-      MemberInfo mi( change.member() );
-      layout->addWidget( new TQLabel( mi.name(), this ), 0, 0 );
+      // TODO change doesn't contain member as struct member .. use SyncMapping to determine the correct member.
+      //MemberInfo mi( change.member() );
+      //layout->addWidget( new TQLabel( mi.name(), this ), 0, 0 );
+      layout->addWidget( new TQLabel( "PORTING TODO", this ), 0, 0 );
 
       TQString type;
       switch ( change.changeType() ) {
diff --git a/kitchensync/src/pluginpicker.cpp b/kitchensync/src/pluginpicker.cpp
index d981599bd..5dda30bfe 100644
--- a/kitchensync/src/pluginpicker.cpp
+++ b/kitchensync/src/pluginpicker.cpp
@@ -24,7 +24,7 @@
 #include "memberinfo.h"
 #include "syncprocessmanager.h"
 
-#include <libqopensync/environment.h>
+#include <libqopensync/pluginenv.h>
 
 #include <kdialog.h>
 #include <kglobal.h>
@@ -77,12 +77,14 @@ void PluginPicker::updatePluginList()
 {
   mPluginList->clear();
 
-  QSync::Environment *env = SyncProcessManager::self()->environment();
+  const QSync::PluginEnv *env = SyncProcessManager::self()->pluginEnv();
+
+  for ( int i = 0; i < env->pluginCount(); ++i ) {
+    QSync::Plugin plugin = env->pluginAt( i );
+
+    if ( plugin.isValid() )
+      mPluginList->appendItem( new PluginItem( mPluginList, plugin ) );
 
-  QSync::Environment::PluginIterator it( env->pluginBegin() );
-  for( ; it != env->pluginEnd(); ++it ) {
-    QSync::Plugin plugin = *it;
-    mPluginList->appendItem( new PluginItem( mPluginList, plugin ) );
   }
 }
 
diff --git a/kitchensync/src/singleconflictdialog.cpp b/kitchensync/src/singleconflictdialog.cpp
index 8975b6f98..121ec50cb 100644
--- a/kitchensync/src/singleconflictdialog.cpp
+++ b/kitchensync/src/singleconflictdialog.cpp
@@ -27,6 +27,7 @@
 
 #include "addresseediffalgo.h"
 #include "genericdiffalgo.h"
+#include "xmldiffalgo.h"
 #include "htmldiffalgodisplay.h"
 #include "memberinfo.h"
 
@@ -43,16 +44,22 @@ SingleConflictDialog::SingleConflictDialog( QSync::SyncMapping &mapping, TQWidge
 
   if ( format == "file" ) {
     mDiffAlgo = new KSync::GenericDiffAlgo( leftChange.data(), rightChange.data() );
-  } else if ( format == "vcard" ) {
-  } else if ( format == "calendar" ) {
-  } else if ( format == "xml-contact" ) {
+  } else if ( format == "vcard21" || format == "vcard30" ) {
     mDiffAlgo = new KSync::AddresseeDiffAlgo( leftChange.data(), rightChange.data() );
+  } else if ( format == "calendar" ) {
+  } else if ( format == "xmlformat-contact" || format == "xmlformat-note"
+	   || format == "xmlformat-event" || format == "xmlformat-todo") { 
+    mDiffAlgo = new KSync::XmlDiffAlgo( leftChange.data(), rightChange.data() );
   }
 
+// TODO: SyncChange doesn't have member as struct member anymore ...
+// Use SyncMapping to determine the member .. see msynctool for example implementation of conlicthandler
+#if 0  
   MemberInfo miLeft( leftChange.member() );
   mDiffAlgoDisplay->setLeftSourceTitle( miLeft.name() );
   MemberInfo miRight( rightChange.member() );
   mDiffAlgoDisplay->setRightSourceTitle( miRight.name() );
+#endif  
 
   if ( mDiffAlgo ) {
     mDiffAlgo->addDisplay( mDiffAlgoDisplay );
@@ -99,6 +106,7 @@ void SingleConflictDialog::initGUI()
   TQGridLayout *layout = new TQGridLayout( this, 3, 4, KDialog::marginHint(), KDialog::spacingHint() );
 
   layout->addMultiCellWidget( new TQLabel( i18n( "A conflict has appeared, please solve it manually." ), this ), 0, 0, 0, 3 );
+
   mDiffAlgoDisplay = new KSync::HTMLDiffAlgoDisplay( this );
 
   layout->addMultiCellWidget( mDiffAlgoDisplay, 1, 1, 0, 3 );
diff --git a/kitchensync/src/syncprocess.cpp b/kitchensync/src/syncprocess.cpp
index 60310b803..2ff93bcd4 100644
--- a/kitchensync/src/syncprocess.cpp
+++ b/kitchensync/src/syncprocess.cpp
@@ -19,10 +19,12 @@
 */
 
 #include <libqopensync/engine.h>
-#include <libqopensync/environment.h>
+#include <libqopensync/member.h>
+#include <libqopensync/result.h>
 
 #include <kdebug.h>
 #include <klocale.h>
+#include <kmessagebox.h>
 
 #include "syncprocess.h"
 #include "syncprocessmanager.h"
@@ -60,8 +62,8 @@ TQString SyncProcess::memberStatus( const QSync::Member& ) const
 
 QSync::Result SyncProcess::addMember( const QSync::Plugin &plugin )
 {
-  QSync::Member member = mGroup.addMember();
-  QSync::Result result = member.instance( plugin );
+  QSync::Member member = mGroup.addMember( plugin );
+  QSync::Result result = member.instance();
 
   if ( !result.isError() )
     mGroup.save();
@@ -69,40 +71,27 @@ QSync::Result SyncProcess::addMember( const QSync::Plugin &plugin )
   return result;
 }
 
+void SyncProcess::removeMember( const QSync::Member &member )
+{
+  member.cleanup();
+  mGroup.removeMember( member );
+  mGroup.save();
+}
+
 void SyncProcess::reinitEngine()
 {
   mEngine->finalize();
   delete mEngine;
   mEngine = new QSync::Engine( mGroup );
   Result result = mEngine->initialize();
-  if ( result.isError() )
+  if ( result.isError() ) {
     kdDebug() << "SyncProcess::reinitEngine: " << result.message() << endl;
+    KMessageBox::error( 0, i18n("Error initializing Synchronization Engine for group \"%1\":\n %2")
+		    .arg( mGroup.name() ).arg( result.message() ) );
 
-  applyObjectTypeFilter();
+  }
 
   emit engineChanged( mEngine );
 }
 
-void SyncProcess::applyObjectTypeFilter()
-{
-  const QSync::Conversion conversion = SyncProcessManager::self()->environment()->conversion();
-  const TQStringList objectTypes = conversion.objectTypes();
-  const TQStringList activeObjectTypes = mGroup.config().activeObjectTypes();
-
-  for ( uint i = 0; i < objectTypes.count(); ++i ) {
-    if ( activeObjectTypes.contains( objectTypes[ i ] ) ) {
-      kdDebug() << "Enabled object type: " <<  objectTypes[ i ] << endl;
-      /*
-       * This is not required. Also this lead to filtering problems when sync with "file-sync".
-       * Uncomment this line again when OpenSync is fixed!
-       *
-       * mGroup.setObjectTypeEnabled( objectTypes[ i ], true );
-       */
-    } else {
-      kdDebug() << "Disabled object type: " <<  objectTypes[ i ] << endl;
-      mGroup.setObjectTypeEnabled( objectTypes[ i ], false );
-    }
-  }
-}
-
 #include "syncprocess.moc"
diff --git a/kitchensync/src/syncprocess.h b/kitchensync/src/syncprocess.h
index ef23f7c52..6cdefc408 100644
--- a/kitchensync/src/syncprocess.h
+++ b/kitchensync/src/syncprocess.h
@@ -44,12 +44,10 @@ class SyncProcess : public QObject
     TQString memberStatus( const QSync::Member &member ) const;
 
     QSync::Result addMember( const QSync::Plugin &plugin );
+    void removeMember( const QSync::Member &member );
 
     void reinitEngine();
 
-    /** apply object type filter hack **/
-    void applyObjectTypeFilter();
-
   signals:
     /**
       This signal is emitted whenever the engine has changed ( reinitialized ).
diff --git a/kitchensync/src/syncprocessmanager.cpp b/kitchensync/src/syncprocessmanager.cpp
index fda111efd..27e09a25e 100644
--- a/kitchensync/src/syncprocessmanager.cpp
+++ b/kitchensync/src/syncprocessmanager.cpp
@@ -23,7 +23,10 @@
 
 #include "syncprocess.h"
 
-#include <libqopensync/environment.h>
+#include <libqopensync/groupenv.h>
+#include <libqopensync/member.h>
+#include <libqopensync/pluginenv.h>
+#include <libqopensync/result.h>
 
 #include <kstaticdeleter.h>
 #include <kmessagebox.h>
@@ -43,14 +46,24 @@ SyncProcessManager *SyncProcessManager::self()
 
 SyncProcessManager::SyncProcessManager()
 {
-  mEnvironment = new QSync::Environment;
-  QSync::Result result = mEnvironment->initialize();
+  mGroupEnv = new QSync::GroupEnv;
+  QSync::Result result = mGroupEnv->initialize();
   if ( result.isError() ) {
     KMessageBox::error( 0, i18n("Error initializing OpenSync.\n%1")
       .arg( result.message() ) );
   } else {
-    init( mEnvironment );
+    initGroup( mGroupEnv );
   }
+
+  mPluginEnv = new QSync::PluginEnv;
+  result = mPluginEnv->initialize();
+  if ( result.isError() ) {
+    KMessageBox::error( 0, i18n("Error initializing OpenSync.\n%1")
+      .arg( result.message() ) );
+  } else {
+//    initPlugin( mPluginEnv );
+  }
+
 }
 
 SyncProcessManager::~SyncProcessManager()
@@ -61,8 +74,8 @@ SyncProcessManager::~SyncProcessManager()
 
   mProcesses.clear();
 
-  mEnvironment->finalize();
-  delete mEnvironment;
+  mGroupEnv->finalize();
+  delete mGroupEnv;
 }
 
 int SyncProcessManager::count() const
@@ -102,8 +115,7 @@ void SyncProcessManager::addGroup( const TQString &name )
 {
   SyncProcess* process = byGroupName( name );
   if ( !process ) {
-    QSync::Group group = mEnvironment->addGroup();
-    group.setName( name );
+    QSync::Group group = mGroupEnv->addGroup( name );
     group.save();
 
     mProcesses.append( new SyncProcess( group ) );
@@ -120,22 +132,21 @@ void SyncProcessManager::remove( SyncProcess *syncProcess )
     const QSync::Group group = syncProcess->group();
     delete syncProcess;
 
-    mEnvironment->removeGroup( group );
+    mGroupEnv->removeGroup( group );
 
     emit changed();
   }
 }
 
-void SyncProcessManager::init( QSync::Environment *environment )
+void SyncProcessManager::initGroup( QSync::GroupEnv *groupEnv )
 {
-  QSync::Environment::GroupIterator it( environment->groupBegin() );
-  for ( ; it != environment->groupEnd(); ++it ) {
+  for ( int i = 0; i < groupEnv->groupCount(); ++i ) {
     /**
      * We check whether the group is valid before we append them
      * to mProcesses. That avoids crashes if the plugin of one of
      * the members isn't loaded (e.g. not installed).
      */
-    const QSync::Group group = *it;
+    const QSync::Group group = groupEnv->groupAt( i );
     int count = group.memberCount();
 
     bool isValid = true;
@@ -149,7 +160,7 @@ void SyncProcessManager::init( QSync::Environment *environment )
     }
 
     if ( isValid )
-      mProcesses.append( new SyncProcess( *it ) );
+      mProcesses.append( new SyncProcess( group ) );
   }
 
   emit changed();
@@ -169,4 +180,13 @@ QSync::Result SyncProcessManager::addMember( SyncProcess *process,
   return result;
 }
 
+void SyncProcessManager::removeMember( SyncProcess *process, const QSync::Member &member )
+{
+  Q_ASSERT( process );
+
+  process->removeMember( member );
+  process->group().save();
+  emit syncProcessChanged( process );
+}
+
 #include "syncprocessmanager.moc"
diff --git a/kitchensync/src/syncprocessmanager.h b/kitchensync/src/syncprocessmanager.h
index b95018a84..38004977d 100644
--- a/kitchensync/src/syncprocessmanager.h
+++ b/kitchensync/src/syncprocessmanager.h
@@ -26,7 +26,8 @@
 #include <libqopensync/group.h>
 
 namespace QSync {
-class Environment;
+class GroupEnv;
+class PluginEnv;
 }
 
 class SyncProcess;
@@ -43,9 +44,14 @@ class SyncProcessManager : public QObject
     ~SyncProcessManager();
 
     /**
-      Return OpenSync Environment.
+      Return OpenSync GroupEnv.
     */
-    QSync::Environment *environment() const { return mEnvironment; }
+    QSync::GroupEnv *groupEnv() const { return mGroupEnv; }
+
+    /**
+      Return OpenSync PluginEnv.
+    */
+    QSync::PluginEnv *pluginEnv() const { return mPluginEnv; }
 
     /**
       Returns the number of SyncProcesses.
@@ -82,6 +88,11 @@ class SyncProcessManager : public QObject
      */
     QSync::Result addMember( SyncProcess *process, const QSync::Plugin &plugin );
 
+    /**
+      Removes the @param member from the group of @param process.
+     */
+    void removeMember( SyncProcess *process, const QSync::Member &member );
+
   signals:
     void changed();
     void syncProcessChanged( SyncProcess *process );
@@ -89,10 +100,12 @@ class SyncProcessManager : public QObject
   private:
     SyncProcessManager();
 
-    void init( QSync::Environment *environment );
+    void initGroup( QSync::GroupEnv *groupEnv );
+//    void initPlugin( QSync::PluginEnv *pluginEnv );
 
     TQValueList<SyncProcess*> mProcesses;
-    QSync::Environment *mEnvironment;
+    QSync::GroupEnv *mGroupEnv;
+    QSync::PluginEnv *mPluginEnv;
 
     static SyncProcessManager *mSelf;
 };
diff --git a/kitchensync/src/xmldiffalgo.cpp b/kitchensync/src/xmldiffalgo.cpp
new file mode 100644
index 000000000..b5f4890fc
--- /dev/null
+++ b/kitchensync/src/xmldiffalgo.cpp
@@ -0,0 +1,166 @@
+/*
+    This file is part of KitchenSync.
+
+    Copyright (c) 2006 Daniel Gollub <dgollub@suse.de> 
+
+    This program 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 "xmldiffalgo.h"
+
+#include <kdebug.h>
+
+using namespace KSync;
+
+#ifndef KDE_USE_FINAL
+// With --enable-final, we get the (identical) compareString from
+// addresseediffalgo.cpp
+//
+static bool compareString( const TQString &left, const TQString &right )
+{
+  if ( left.isEmpty() && right.isEmpty() )
+    return true;
+  else
+    return left == right;
+}
+#endif
+
+XmlDiffAlgo::XmlDiffAlgo( const TQString &leftXml, const TQString &rightXml )
+{
+  kdDebug() << __func__ << " " << __LINE__ << endl;
+
+  mLeftXml.setContent( leftXml );
+  mRightXml.setContent( rightXml );
+
+}
+
+XmlDiffAlgo::XmlDiffAlgo( const TQDomDocument &leftXml, const TQDomDocument &rightXml )
+  : mLeftXml( leftXml ), mRightXml( rightXml )
+{
+  kdDebug() << __func__ << " " << __LINE__ << endl;
+}
+
+void XmlDiffAlgo::appendSingleNodes(TQDomElement &element, bool isLeft)
+{
+  TQDomNode node;
+
+  for ( node = element.firstChild(); !node.isNull(); node = node.nextSibling() ) {
+    TQDomElement child = node.toElement();
+
+    if (isLeft)
+      additionalLeftField( node.nodeName(), child.text() );
+    else
+      additionalRightField( node.nodeName(), child.text() );
+  }
+
+}
+
+void XmlDiffAlgo::appendConflictNodes(TQDomElement &leftElement, TQDomElement &rightElement)
+{
+  TQDomNode left, right;
+  TQDomElement leftChild, rightChild;
+
+  for ( left = leftElement.firstChild(); !left.isNull(); left = left.nextSibling() ) {
+    leftChild = left.toElement();
+
+    for ( right = rightElement.firstChild(); !right.isNull(); right = right.nextSibling() ) {
+      rightChild = right.toElement();
+
+      if ( leftChild.tagName() != rightChild.tagName() )
+        continue;
+
+      if (leftChild.text().isEmpty() || rightChild.text().isEmpty())
+        continue;
+
+      TQString id = leftChild.tagName();
+      if (id == "Content")
+        id = left.parentNode().nodeName();
+
+      conflictField( id, leftChild.text(), rightChild.text() );
+
+      left.parentNode().removeChild( left );
+      left = leftElement.firstChild();
+
+      right.parentNode().removeChild( right );
+      right = rightElement.firstChild();
+
+    }
+  }
+}
+
+void XmlDiffAlgo::compareNode(TQDomElement &leftElement, TQDomElement &rightElement)
+{
+  TQDomNode left, right;
+  TQDomElement leftChild, rightChild;
+  TQDomNodeList nlist;
+top:;
+
+  for ( left = leftElement.firstChild(); !left.isNull(); left = left.nextSibling() ) {
+    leftChild = left.toElement();
+
+    for ( right = rightElement.firstChild(); !right.isNull(); right = right.nextSibling() ) {
+      rightChild = right.toElement();
+
+      if (leftChild.tagName() != rightChild.tagName())
+        continue;
+
+      if ( left.childNodes().count() > 1 && right.childNodes().count() > 1 ) {
+        compareNode( leftChild, rightChild );
+
+        if ( !left.hasChildNodes() && !right.hasChildNodes() ) {
+          left.parentNode().removeChild( left );
+          right.parentNode().removeChild( right );
+          goto top;
+        }
+
+        break;
+      }
+
+      if ( leftChild.text() == rightChild.text() ) {
+        TQString id = leftChild.tagName();
+
+        if ( id == "Content" )
+          id = left.parentNode().nodeName(); 
+ 
+	if ( id != "Type" )
+          //matchingField( id, leftChild.text(), rightChild.text() );
+
+        left.parentNode().removeChild( left );
+        right.parentNode().removeChild( right );
+        goto top;
+      }
+    }
+  }
+
+  appendConflictNodes(rightElement, leftElement);
+
+  appendSingleNodes(rightElement, false);
+  appendSingleNodes(leftElement, true);
+}
+
+void XmlDiffAlgo::run()
+{
+  kdDebug() << __func__ << endl;	
+  begin();
+
+  TQDomElement leftElement = mLeftXml.documentElement();
+  TQDomElement rightElement = mRightXml.documentElement();
+
+  compareNode( leftElement, rightElement );
+
+  end();
+}
+
diff --git a/kitchensync/src/xmldiffalgo.h b/kitchensync/src/xmldiffalgo.h
new file mode 100644
index 000000000..f1f21d3f4
--- /dev/null
+++ b/kitchensync/src/xmldiffalgo.h
@@ -0,0 +1,54 @@
+/*
+    This file is part of KitchenSync 
+
+    Copyright (c) 2006 Daniel Gollub <dgollub@suse.de>
+
+    This program 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 KSYNC_XMLDIFFALGO_H
+#define KSYNC_XMLDIFFALGO_H
+
+#include <tqdom.h>
+
+#include <libkdepim/diffalgo.h>
+
+using namespace KPIM;
+
+namespace KSync {
+
+class XmlDiffAlgo : public DiffAlgo
+{
+  public:
+    XmlDiffAlgo( const TQString &leftXml, const TQString &rightXml );
+    XmlDiffAlgo( const TQDomDocument &leftXml, const TQDomDocument &rightXml );
+
+    void run();
+
+  private:
+    void appendConflictNodes(TQDomElement &leftElement, TQDomElement &rightElement);
+    void appendSingleNodes(TQDomElement &element, bool isLeft);
+
+
+    void compareNode(TQDomElement &leftElement, TQDomElement &rightElement);
+
+    TQDomDocument mLeftXml;
+    TQDomDocument mRightXml;
+};
+
+}
+
+#endif