Attachment #139362 for bug #202974

Lines 1-7 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/configure.in.bot (-2 / +2 lines)
1	if test "$HAVE_OPENSYNC" = 0 -o "$HAVE_OPENSYNC_ENGINE" = 0; then	1	if test "$HAVE_OPENSYNC" = 0; then
2	echo ""	2	echo ""
3	echo "You're missing a compatible version of libopensync."	3	echo "You're missing a compatible version of libopensync."
4	echo "Version 0.19 or greater is needed."	4	echo "Version 0.31 or greater is needed."
5	echo "kitchensync will not be built."	5	echo "kitchensync will not be built."
6	echo ""	6	echo ""
7	all_tests=bad	7	all_tests=bad






HAVE_OPENSYNC=0
PKG_CHECK_MODULES(OPENSYNC, opensync-1.0 >= 0.33, HAVE_OPENSYNC=1,HAVE_OPENSYNC=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(LIBXML,   libxml-2.0, , HAVE_OPENSYNC=0)
PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.6, , HAVE_OPENSYNC=0)


AC_SUBST(OPENSYNC_HEADERDIR)

dnl Check if we can compile KitchenSync
AM_CONDITIONAL(compile_kitchensync, test "$HAVE_OPENSYNC" = 1)

if test "$HAVE_OPENSYNC" = 1; then
    AC_MSG_RESULT([found])
else
    AC_MSG_RESULT([not found])




    Boston, MA 02110-1301, USA.
*/

#include <opensync/opensync.h>
#include <opensync/opensync-engine.h>
#include <libqopensync/engine.h>

#include <qapplication.h>

#include "engine.h"

#include "callbackhandler.h"

using namespace QSync;

{
  mEngine = engine;

  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

  }
}

void CallbackHandler::conflict_callback( OSyncEngine *engine, OSyncMappingEngine *omapping, void *data )
{
  SyncMapping mapping( omapping, engine );


  QApplication::postEvent( handler, new ConflictEvent( mapping ) );
}

void CallbackHandler::change_callback( OSyncChangeUpdate *update, void *data )
{
  SyncChangeUpdate change( update );


  QApplication::postEvent( handler, new MappingEvent( mapping ) );
}

void CallbackHandler::engine_callback( OSyncEngineUpdate *update, void *data )
{
  SyncEngineUpdate engine( update );


Lines 76-85 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/callbackhandler.h (-3 / +3 lines)
76	class EngineEvent;	76	class EngineEvent;
77	class MemberEvent;	77	class MemberEvent;
78		78
79	static void conflict_callback( OSyncEngine, OSyncMapping, void* );	79	static void conflict_callback( OSyncEngine, OSyncMappingEngine, void* );
80	static void change_callback( OSyncEngine, OSyncChangeUpdate, void* );	80	static void change_callback( OSyncChangeUpdate, void );
81	static void mapping_callback( OSyncMappingUpdate, void );	81	static void mapping_callback( OSyncMappingUpdate, void );
82	static void engine_callback( OSyncEngine, OSyncEngineUpdate, void* );	82	static void engine_callback( OSyncEngineUpdate, void );
83	static void member_callback( OSyncMemberUpdate, void );	83	static void member_callback( OSyncMemberUpdate, void );
84		84
85	Engine* mEngine;	85	Engine* mEngine;

Lines 20-25 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/conversion.cpp (-6 / +11 lines)
20	*/	20	*/
21		21
22	#include <opensync/opensync.h>	22	#include <opensync/opensync.h>
		23	#include <opensync/opensync-format.h>
23		24
24	#include "conversion.h"	25	#include "conversion.h"
25		26
Lines 43-58 Link Here
43	{	44	{
44	Q_ASSERT( mEnvironment );	45	Q_ASSERT( mEnvironment );
45		46
46	OSyncFormatEnv *formatEnv = osync_conv_env_new( mEnvironment );	47	OSyncError *error = NULL;
		48	OSyncFormatEnv *formatEnv = osync_format_env_new( &error );
47	Q_ASSERT( formatEnv );	49	Q_ASSERT( formatEnv );
48		50
		51	osync_format_env_load_plugins(formatEnv, NULL, &error);
		52
49	QStringList types;	53	QStringList types;
50	for ( int i = 0; i < osync_conv_num_objtypes( formatEnv ); i++ ) {
51	OSyncObjType *type = osync_conv_nth_objtype( formatEnv, i );
52	types.append( QString::fromUtf8( osync_objtype_get_name( type ) ) );
53	}
54		54
55	osync_conv_env_free( formatEnv );	55	for (int i = 0; i < osync_format_env_num_objformats(formatEnv); i++) {
		56	OSyncObjFormat *format = osync_format_env_nth_objformat(formatEnv, i);
		57	types.append( QString::fromUtf8( osync_objformat_get_objtype(format) ) );
		58	}
		59
		60	osync_format_env_free( formatEnv );
56		61
57	return types;	62	return types;
58	}	63	}





#include <qstringlist.h>

class OSyncGroupEnv;

namespace QSync {

class Conversion
{
  friend class PluginEnv;

  public:
    Conversion();

    QStringList objectTypes() const;

  private:
    OSyncGroupEnv *mGroupEnv;
};

}




*/

#include <opensync/opensync.h>
#include <opensync/opensync-engine.h>

#include "group.h"
#include "member.h"
#include "result.h"

#include "engine.h"


Engine::Engine( const Group &group )
{
  OSyncError *error = 0;
  mEngine = osync_engine_new( group.mGroup, &error );
}

Engine::~Engine()
{
  osync_engine_unref( mEngine );
  mEngine = 0;
}

Result Engine::initialize()
{
  Q_ASSERT( mEngine );

  OSyncError *error = 0;
  if ( !osync_engine_initialize	( mEngine, &error ) )
    return Result( &error );
  else
    return Result();


void Engine::finalize()
{
  Q_ASSERT( mEngine );

  OSyncError *error = 0;
  osync_engine_finalize( mEngine , &error );
}

Result Engine::synchronize()
{
  Q_ASSERT( mEngine );

  OSyncError *error = 0;
  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();


void Engine::abort()
{
  Q_ASSERT( mEngine );

// TODO
//  osync_engine_abort( mEngine );
}


Lines 22-33 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/engine.h (-2 / +9 lines)
22	#ifndef QSYNC_ENGINE_H	22	#ifndef QSYNC_ENGINE_H
23	#define QSYNC_ENGINE_H	23	#define QSYNC_ENGINE_H
24		24
25	#include <libqopensync/group.h>
26
27	class OSyncEngine;	25	class OSyncEngine;
28		26
29	namespace QSync {	27	namespace QSync {
30		28
		29	class Group;
		30	class Member;
		31	class Result;
		32
31	class Engine	33	class Engine
32	{	34	{
33	friend class CallbackHandler;	35	friend class CallbackHandler;
Lines 59-64 Link Here
59	Result synchronize();	61	Result synchronize();
60		62
61	/**	63	/**
		64	Starts the discover process for a certain member.
		65	*/
		66	Result discover( const Member &member );
		67
		68	/**
62	Stops the synchronization process.	69	Stops the synchronization process.
63	*/	70	*/
64	void abort();	71	void abort();




/*
    This file is part of libqopensync.

    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#include "environment.h"

#include <opensync/opensync.h>

using namespace QSync;

Environment::Environment()
{
  mEnvironment = osync_env_new();
}

Environment::~Environment()
{
  osync_env_free( mEnvironment );
}

Environment::GroupIterator Environment::groupBegin()
{
  GroupIterator it( this );
  it.mPos = 0;

  return it;
}

Environment::GroupIterator Environment::groupEnd()
{
  GroupIterator it( this );
  it.mPos = groupCount();

  return it;
}

Environment::PluginIterator Environment::pluginBegin()
{
  PluginIterator it( this );
  it.mPos = 0;

  return it;
}

Environment::PluginIterator Environment::pluginEnd()
{
  PluginIterator it( this );
  it.mPos = pluginCount();

  return it;
}

Result Environment::initialize()
{
  OSyncError *error = 0;
  if ( !osync_env_initialize( mEnvironment, &error ) )
    return Result( &error );
  else
    return Result();
}

Result Environment::finalize()
{
  OSyncError *error = 0;
  if ( !osync_env_finalize( mEnvironment, &error ) )
    return Result( &error);
  else
    return Result();
}

int Environment::groupCount() const
{
  return osync_env_num_groups( mEnvironment );
}

Group Environment::groupAt( int pos ) const
{
  Group group;

  if ( pos < 0 || pos >= groupCount() )
    return group;

  OSyncGroup *ogroup = osync_env_nth_group( mEnvironment, pos );
  group.mGroup = ogroup;

  return group;
}

Group Environment::groupByName( const QString &name ) const
{
  Group group;

  OSyncGroup *ogroup = osync_env_find_group( mEnvironment, name.latin1() );
  if ( ogroup )
    group.mGroup = ogroup;

  return group;
}

Group Environment::addGroup()
{
  Group group;

  OSyncGroup *ogroup = osync_group_new( mEnvironment );
  if ( ogroup )
    group.mGroup = ogroup;

  return group;
}

Result Environment::removeGroup( const Group &group )
{
  OSyncError *error = 0;
  if ( !osync_group_delete( group.mGroup, &error ) )
    return Result( &error );
  else
    return Result();
}

int Environment::pluginCount() const
{
  return osync_env_num_plugins( mEnvironment );
}

Plugin Environment::pluginAt( int pos ) const
{
  Plugin plugin;

  if ( pos < 0 || pos >= pluginCount() )
    return plugin;

  OSyncPlugin *oplugin = osync_env_nth_plugin( mEnvironment, pos );
  plugin.mPlugin = oplugin;

  return plugin;
}

Plugin Environment::pluginByName( const QString &name ) const
{
  Plugin plugin;

  OSyncPlugin *oplugin = osync_env_find_plugin( mEnvironment, name.latin1() );
  if ( oplugin )
    plugin.mPlugin = oplugin;

  return plugin;
}

Conversion Environment::conversion() const
{
  Conversion conversion;
  conversion.mEnvironment = mEnvironment;

  return conversion;
}




/*
    This file is part of libqopensync.

    Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#ifndef OSYNC_ENVIRONMENT_H
#define OSYNC_ENVIRONMENT_H

#include <qstring.h>

#include <libqopensync/group.h>
#include <libqopensync/plugin.h>
#include <libqopensync/result.h>
#include <libqopensync/conversion.h>

struct OSyncEnv;

namespace QSync {

class Environment
{
  public:
    Environment();
    ~Environment();

    class GroupIterator
    {
      friend class Environment;

      public:
        GroupIterator( Environment *environment )
          : mEnvironment( environment ), mPos( -1 )
        {
        }

        GroupIterator( const GroupIterator &it )
        {
          mEnvironment = it.mEnvironment;
          mPos = it.mPos;
        }

        Group operator*() 
        {
          return mEnvironment->groupAt( mPos );
        }

        GroupIterator &operator++() { mPos++; return *this; }
        GroupIterator &operator++( int ) { mPos++; return *this; }
        GroupIterator &operator--() { mPos--; return *this; }
        GroupIterator &operator--( int ) { mPos--; return *this; }
        bool operator==( const GroupIterator &it ) { return mEnvironment == it.mEnvironment && mPos == it.mPos; }
        bool operator!=( const GroupIterator &it ) { return mEnvironment == it.mEnvironment && mPos != it.mPos; }

      private:
        Environment *mEnvironment;
        int mPos;
    };

    class PluginIterator
    {
      friend class Environment;

      public:
        PluginIterator( Environment *environment )
          : mEnvironment( environment ), mPos( -1 )
        {
        }

        PluginIterator( const PluginIterator &it )
        {
          mEnvironment = it.mEnvironment;
          mPos = it.mPos;
        }

        Plugin operator*() 
        {
          return mEnvironment->pluginAt( mPos );
        }

        PluginIterator &operator++() { mPos++; return *this; }
        PluginIterator &operator++( int ) { mPos++; return *this; }
        PluginIterator &operator--() { mPos--; return *this; }
        PluginIterator &operator--( int ) { mPos--; return *this; }
        bool operator==( const PluginIterator &it ) { return mEnvironment == it.mEnvironment && mPos == it.mPos; }
        bool operator!=( const PluginIterator &it ) { return mEnvironment == it.mEnvironment && mPos != it.mPos; }

      private:
        Environment *mEnvironment;
        int mPos;
    };

    /**
      Returns an iterator pointing to the first item in the group list.
      This iterator equals groupEnd() if the group list is empty.
     */
    GroupIterator groupBegin();

    /**
      Returns an iterator pointing past the last item in the group list.
      This iterator equals groupBegin() if the group list is empty.
     */
    GroupIterator groupEnd();

    /**
      Returns an iterator pointing to the first item in the plugin list.
      This iterator equals pluginEnd() if the group list is empty.
     */
    PluginIterator pluginBegin();

    /**
      Returns an iterator pointing past the last item in the plugin list.
      This iterator equals pluginBegin() if the plugin list is empty.
     */
    PluginIterator pluginEnd();

    /**
      Initializes the environment ( e.g. loads the groups and plugins ).
      Has to be called before the groups or plugins can be accessed.
     */
    Result initialize();

    /**
      Finalizes the environment ( e.g. unloads the groups and plugins ).
      Should be the last call before the object is deleted.
     */
    Result finalize();

    /**
      Returns the number of groups.
     */
    int groupCount() const;

    /**
      Returns the group at position @param pos.
     */
    Group groupAt( int pos ) const;

    /**
      Returns a group by name or an invalid group when the group with this
      name doesn't exists.
     */
    Group groupByName( const QString &name ) const;

    /**
      Adds a new group to the environment.

      @returns the new group.
     */
    Group addGroup();

    /**
      Removes a group from the environment.
     */
    Result removeGroup( const Group &group );

    /**
      Returns the number of plugins.
     */
    int pluginCount() const;

    /**
      Returns the plugin at position @param pos.
     */
    Plugin pluginAt( int pos ) const;

    /**
      Returns a plugin by name or an invalid plugin when the plugin with this
      name doesn't exists.
     */
    Plugin pluginByName( const QString &name ) const;

    /**
      Returns the conversion object of this environment.
     */
    Conversion conversion() const;

  private:
    OSyncEnv *mEnvironment;
};

}

#endif

Lines 20-25 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/filter.cpp (+1 lines)
20	*/	20	*/
21		21
22	#include <opensync/opensync.h>	22	#include <opensync/opensync.h>
		23	#include <opensync/opensync-format.h>
23		24
24	#include "filter.h"	25	#include "filter.h"
25		26




/** 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 )
{
}

QStringList GroupConfig::activeObjectTypes() const
{
  Q_ASSERT( mGroup );

  const QString fileName = QString( "%1/filter.conf" ).arg( osync_group_get_configdir( mGroup ) );

  QFile file( fileName );
  if ( !file.open( IO_ReadOnly ) )
    return QStringList();

  QDomDocument document;

  QString message;
  if ( !document.setContent( &file, &message ) ) {
    qDebug( "Error on loading %s: %s", fileName.latin1(), message.latin1() );
    return QStringList();
  }
  file.close();

  QStringList objectTypes;

  QDomElement element = document.documentElement();
  QDomNode node = element.firstChild();
  while ( !node.isNull() ) {
    QDomElement childElement = node.toElement();
    if ( !childElement.isNull() )
      objectTypes.append( childElement.tagName() );

    node = node.nextSibling();
  }

  return objectTypes;
}

void GroupConfig::setActiveObjectTypes( const QStringList &objectTypes )
{
  Q_ASSERT( mGroup );

  QDomDocument document( "Filter" );
  document.appendChild( document.createProcessingInstruction(
                        "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );

  QDomElement element = document.createElement( "filter" );
  document.appendChild( element );

  for ( uint i = 0; i < objectTypes.count(); ++i ) {
    QDomElement entry = document.createElement( objectTypes[ i ] );
    element.appendChild( entry );
  }

  const QString fileName = QString( "%1/filter.conf" ).arg( osync_group_get_configdir( mGroup ) );

  QFile file( fileName );
  if ( !file.open( IO_WriteOnly ) )
    return;

  QTextStream s( &file );
  s.setEncoding( QTextStream::UnicodeUTF8 );
  s << document.toString();
  file.close();
}


Group::Group()
  : mGroup( 0 )
{

  return ( mGroup != 0 );
}

Group::Iterator Group::begin()
{
  Iterator it( this );
  it.mPos = 0;

  return it;
}

Group::Iterator Group::end()
{
  Iterator it( this );
  it.mPos = memberCount();

  return it;
}

void Group::setName( const QString &name )
{
  Q_ASSERT( mGroup );

  }
}

void Group::unlock()
{
  Q_ASSERT( mGroup );

  osync_group_unlock( mGroup );
}

Member Group::addMember( const QSync::Plugin &plugin )
{
  Q_ASSERT( 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;

    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 QString &objectType, bool enabled )
{
  Q_ASSERT( mGroup );

  return osync_group_objtype_enabled( mGroup, objectType.utf8() );
}

Result Group::cleanup() const
{
  Q_ASSERT( mGroup );

  OSyncError *error = 0;
  if ( !osync_group_delete( mGroup, &error ) )
    return Result( &error );
  else
    return Result();
}




/*
    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 QString &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 QString &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 );
}




/*
    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 <qstring.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 QString &name ) const;

    /**
      Adds a new group to the environment.

      @returns the new group.
     */
    Group addGroup( const QString &name );

    /**
      Removes a group from the environment.
     */
    void removeGroup( const Group &group );

  private:
    OSyncGroupEnv *mGroupEnv;
};

}

#endif




#include <qdatetime.h>
#include <qstringlist.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();

    QStringList activeObjectTypes() const;
    void setActiveObjectTypes( const QStringList &objectTypes );

  private:
    OSyncGroup *mGroup;
};


class Group
{
  friend class Engine;
  friend class GroupEnv;

  public:
    enum LockType

     */
    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.
     */


    /**
      Unlocks the group.

      @param removeFile Whether the lock file shall be removed.
     */
    void unlock();

    /**
      Adds a new member to the group.

      @returns the new member.
     */
    Member addMember( const QSync::Plugin &plugin );

    /**
      Removes a member from the group.

    bool isObjectTypeEnabled( const QString &objectType ) const;

    /**
      Sets whether this group uses the merger for synchronization.
     */
    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 whether this group uses the converter for synchronization.
     */
    bool useConverter() const;

    /**
      Saves the configuration to hard disc.
     */
    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;
};




           -I$(top_srcdir)/kitchensync \
           -I$(top_srcdir) \
           $(OPENSYNC_CFLAGS) \
           $(GLIB_CFLAGS) \
           $(all_includes)

lib_LTLIBRARIES = libqopensync.la

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

# 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


Lines 20-27 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/member.cpp (-51 / +22 lines)
20	*/	20	*/
21		21
22	#include <opensync/opensync.h>	22	#include <opensync/opensync.h>
		23	#include <opensync/opensync-group.h>
		24
23	#include <stdlib.h>	25	#include <stdlib.h>
24		26
		27	#include "result.h"
		28
25	#include "member.h"	29	#include "member.h"
26		30
27	using namespace QSync;	31	using namespace QSync;
Lines 42-50 Link Here
42	if ( !mMember )	46	if ( !mMember )
43	return false;	47	return false;
44		48
45	if ( !osync_member_instance_plugin( mMember, pluginName().utf8(), &error ) ) {	49	if ( !osync_member_load( mMember, configurationDirectory().utf8(), &error ) ) {
46	qDebug( "Plugin %s is not valid: %s", pluginName().latin1(), osync_error_print( &error ) );	50	qDebug( "Plugin %s is not valid: %s", pluginName().latin1(), osync_error_print( &error ) );
47	osync_error_free( &error );	51	osync_error_unref( &error );
48	return false;	52	return false;
49	}	53	}
50		54
Lines 65-83 Link Here
65	return QString::fromLatin1( osync_member_get_pluginname( mMember ) );	69	return QString::fromLatin1( osync_member_get_pluginname( mMember ) );
66	}	70	}
67		71
68	Plugin Member::plugin() const
69	{
70	Q_ASSERT( mMember );
71
72	Plugin plugin;
73
74	OSyncPlugin *oplugin = osync_member_get_plugin( mMember );
75	if ( oplugin )
76	plugin.mPlugin = oplugin;
77
78	return plugin;
79	}
80
81	int Member::id() const	72	int Member::id() const
82	{	73	{
83	Q_ASSERT( mMember );	74	Q_ASSERT( mMember );
Lines 103-129 Link Here
103	{	94	{
104	Q_ASSERT( mMember );	95	Q_ASSERT( mMember );
105		96
106	osync_member_set_config( mMember, configurationData.data(), configurationData.size() );	97	osync_member_set_config( mMember, configurationData.data() );
107	}	98	}
108		99
109	Result Member::configuration( QByteArray &configurationData, bool useDefault )	100	Result Member::configuration( QByteArray &configurationData, bool useDefault )
110	{	101	{
111	Q_ASSERT( mMember );	102	Q_ASSERT( mMember );
112		103
113	char *data;	104	const char *data;
114	int size;	105	int size = 0;
115		106
116	OSyncError *error = 0;	107	OSyncError *error = 0;
117	osync_bool ok = false;
118	if ( useDefault )	108	if ( useDefault )
119	ok = osync_member_get_config_or_default( mMember, &data, &size, &error );	109	data = osync_member_get_config_or_default( mMember, &error );
120	else	110	else
121	ok = osync_member_get_config( mMember, &data, &size, &error );	111	data = osync_member_get_config( mMember, &error );
122		112
123	if ( !ok ) {	113
		114	if ( !data ) {
124	return Result( &error );	115	return Result( &error );
125	} else {	116	} else {
126	configurationData.resize( size );	117	size = strlen(data);
		118	configurationData.resize( size );
127	memcpy( configurationData.data(), data, size );	119	memcpy( configurationData.data(), data, size );
128		120
129	return Result();	121	return Result();
Lines 141-150 Link Here
141	return Result();	133	return Result();
142	}	134	}
143		135
144	Result Member::instance( const Plugin &plugin )	136	Result Member::instance()
145	{	137	{
146	OSyncError *error = 0;	138	OSyncError *error = 0;
147	if ( !osync_member_instance_plugin( mMember, plugin.name().utf8(), &error ) )	139	if ( !osync_member_load( mMember, configurationDirectory().utf8(), &error ) )
148	return Result( &error );	140	return Result( &error );
149	else	141	else
150	return Result();	142	return Result();
Lines 155-188 Link Here
155	return mMember == member.mMember;	147	return mMember == member.mMember;
156	}	148	}
157		149
158	QString Member::scanDevices( const QString &query )	150	Result Member::cleanup() const
159	{
160	Q_ASSERT( mMember );
161
162	OSyncError *error = 0;
163	char data = (char)osync_member_call_plugin( mMember, "scan_devices", const_cast<char*>( query.utf8().data() ), &error );
164	if ( error != 0 ) {
165	osync_error_free( &error );
166	return QString();
167	} else {
168	QString xml = QString::fromUtf8( data );
169	free( data );
170	return xml;
171	}
172	}
173
174	bool Member::testConnection( const QString &configuration )
175	{	151	{
176	Q_ASSERT( mMember );	152	Q_ASSERT( mMember );
177		153
178	OSyncError *error = 0;	154	OSyncError *error = 0;
179	int result = (int)osync_member_call_plugin( mMember, "test_connection", const_cast<char*>( configuration.utf8().data() ), &error );	155	if ( !osync_member_delete( mMember, &error ) )
180	if ( error != 0 ) {	156	return Result( &error );
181	osync_error_free( &error );	157	else
182	return false;	158	return Result();
183	} else {
184	bool value = ( *result == 1 ? true : false );
185	free( result );
186	return value;
187	}
188	}	159	}




#ifndef QSYNC_MEMBER_H
#define QSYNC_MEMBER_H

#include <qstring.h>
#include <libqopensync/result.h>
#include <libqopensync/plugin.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();

    QString pluginName() const;

    /**
      Returns the plugin, the member belongs to.
     */
    Plugin plugin() const;

    /**
      Returns the id of the plugin.
    */
    int id() const;

    /**
      Make this member an instance of the given plugin.
    */
    Result instance();

    bool operator==( const Member& ) const;


     */
    bool testConnection( const QString &configuration );


    /**
     * Deletes the member's information from the hard disc.
     */
    Result cleanup() const;

  private:
    OSyncMember *mMember;
};

Lines 20-25 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/plugin.cpp (+1 lines)
20	*/	20	*/
21		21
22	#include <opensync/opensync.h>	22	#include <opensync/opensync.h>
		23	#include <opensync/opensync-plugin.h>
23		24
24	#include "plugin.h"	25	#include "plugin.h"
25		26




/*
    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 QString &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;
}
*/




/*
    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 <qstring.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 QString &name ) const;

    /**
      Returns the conversion object of this environment.
     */
//    Conversion conversion() const;

  private:
    OSyncPluginEnv *mPluginEnv;
};

}

#endif

Lines 30-36 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/plugin.h (-1 / +1 lines)
30		30
31	class Plugin	31	class Plugin
32	{	32	{
33	friend class Environment;	33	friend class PluginEnv;
34	friend class Member;	34	friend class Member;
35		35
36	public:	36	public:

Lines 100-106 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/result.cpp (-1 / +1 lines)
100	mMessage = QString::fromUtf8( osync_error_print( error ) );	100	mMessage = QString::fromUtf8( osync_error_print( error ) );
101		101
102	if ( deleteError )	102	if ( deleteError )
103	osync_error_free( error );	103	osync_error_unref( error );
104	}	104	}
105		105
106	Result::~Result()	106	Result::~Result()

Lines 19-26 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/syncchange.cpp (-17 / +34 lines)
19	Boston, MA 02110-1301, USA.	19	Boston, MA 02110-1301, USA.
20	*/	20	*/
21		21
		22	#include <stdlib.h>
		23
22	#include <opensync/file.h>	24	#include <opensync/file.h>
		25
23	#include <opensync/opensync.h>	26	#include <opensync/opensync.h>
		27	#include <opensync/opensync-data.h>
		28	#include <opensync/opensync-format.h>
24		29
25	#include "syncchange.h"	30	#include "syncchange.h"
26		31
Lines 64-102 Link Here
64	return QString::fromUtf8( osync_change_get_hash( mSyncChange ) );	69	return QString::fromUtf8( osync_change_get_hash( mSyncChange ) );
65	}	70	}
66		71
67	void SyncChange::setData( const QString &data )	72	void SyncChange::setData( const QString &data , OSyncObjFormat *format )
68	{	73	{
69	osync_change_set_data( mSyncChange, const_cast<char*>( data.utf8().data() ), data.utf8().size(), true );	74	OSyncError *error = 0;
		75
		76	OSyncData odata = osync_data_new( const_cast<char>( data.utf8().data() ), data.utf8().size(), format, &error );
		77	osync_change_set_data( mSyncChange, odata );
70	}	78	}
71		79
72	QString SyncChange::data() const	80	QString SyncChange::data() const
73	{	81	{
74	int size = osync_change_get_datasize( mSyncChange );	82	char *buf;
		83	unsigned int size;
		84
		85	OSyncData *data = osync_change_get_data( mSyncChange );
		86
		87	osync_data_get_data( data, &buf, &size );
75		88
76	QString content;	89	QString content;
77	if ( objectFormatName() == "file" ) {	90	if ( objectFormatName() == "file" ) {
78	fileFormat format = (fileFormat)osync_change_get_data( mSyncChange );	91	OSyncFileFormat format = (OSyncFileFormat) buf;
79	if ( format )	92	if ( format )
80	content = QString::fromUtf8( format->data, format->size );	93	content = QString::fromUtf8( format->data, format->size );
81	} else	94	} else
82	content = QString::fromUtf8( osync_change_get_data( mSyncChange ), size );	95	content = QString::fromUtf8( buf, size );
		96
		97	free( buf );
83		98
84	return content;	99	return content;
85	}	100	}
86		101
87	bool SyncChange::hasData() const	102	bool SyncChange::hasData() const
88	{	103	{
89	return osync_change_has_data( mSyncChange );	104	return osync_data_has_data( osync_change_get_data( mSyncChange ) );
90	}	105	}
91		106
92	QString SyncChange::objectFormatName() const	107	QString SyncChange::objectFormatName() const
93	{	108	{
94	OSyncObjFormat *format = osync_change_get_objformat( mSyncChange );	109	OSyncObjFormat *format = osync_data_get_objformat( osync_change_get_data( mSyncChange ) );
95	Q_ASSERT( format );	110	Q_ASSERT( format );
96		111
97	return QString::fromUtf8( osync_objformat_get_name( format ) );	112	return QString::fromUtf8( osync_objformat_get_name( format ) );
98	}	113	}
99		114
		115	/*
100	Member SyncChange::member() const	116	Member SyncChange::member() const
101	{	117	{
102	OSyncMember *omember = osync_change_get_member( mSyncChange );	118	OSyncMember *omember = osync_change_get_member( mSyncChange );
Lines 106-111 Link Here
106		122
107	return m;	123	return m;
108	}	124	}
		125	*/
109		126
110	void SyncChange::setChangeType( Type changeType )	127	void SyncChange::setChangeType( Type changeType )
111	{	128	{
Lines 113-132 Link Here
113		130
114	switch ( changeType ) {	131	switch ( changeType ) {
115	case AddedChange:	132	case AddedChange:
116	ochangeType = CHANGE_ADDED;	133	ochangeType = OSYNC_CHANGE_TYPE_ADDED;
117	break;	134	break;
118	case UnmodifiedChange:	135	case UnmodifiedChange:
119	ochangeType = CHANGE_UNMODIFIED;	136	ochangeType = OSYNC_CHANGE_TYPE_UNMODIFIED;
120	break;	137	break;
121	case DeletedChange:	138	case DeletedChange:
122	ochangeType = CHANGE_DELETED;	139	ochangeType = OSYNC_CHANGE_TYPE_DELETED;
123	break;	140	break;
124	case ModifiedChange:	141	case ModifiedChange:
125	ochangeType = CHANGE_MODIFIED;	142	ochangeType = OSYNC_CHANGE_TYPE_MODIFIED;
126	break;	143	break;
127	case UnknownChange:	144	case UnknownChange:
128	default:	145	default:
129	ochangeType = CHANGE_UNKNOWN;	146	ochangeType = OSYNC_CHANGE_TYPE_UNKNOWN;
130	break;	147	break;
131	}	148	}
132		149
Lines 138-156 Link Here
138	OSyncChangeType ochangeType = osync_change_get_changetype( mSyncChange );	155	OSyncChangeType ochangeType = osync_change_get_changetype( mSyncChange );
139		156
140	switch ( ochangeType ) {	157	switch ( ochangeType ) {
141	case CHANGE_ADDED:	158	case OSYNC_CHANGE_TYPE_ADDED:
142	return AddedChange;	159	return AddedChange;
143	break;	160	break;
144	case CHANGE_UNMODIFIED:	161	case OSYNC_CHANGE_TYPE_UNMODIFIED:
145	return UnmodifiedChange;	162	return UnmodifiedChange;
146	break;	163	break;
147	case CHANGE_DELETED:	164	case OSYNC_CHANGE_TYPE_DELETED:
148	return DeletedChange;	165	return DeletedChange;
149	break;	166	break;
150	case CHANGE_MODIFIED:	167	case OSYNC_CHANGE_TYPE_MODIFIED:
151	return ModifiedChange;	168	return ModifiedChange;
152	break;	169	break;
153	case CHANGE_UNKNOWN:	170	case OSYNC_CHANGE_TYPE_UNKNOWN:
154	default:	171	default:
155	return UnknownChange;	172	return UnknownChange;
156	break;	173	break;




#include <libqopensync/member.h>

class OSyncChange;
class OSyncObjFormat;

namespace QSync {


    /**
      Sets the data provided by the plugin.
     */
    void setData( const QString &data, OSyncObjFormat *format );

    /**
      Returns the data provided by the plugin.

    /**
      Returns the parent member of this change.
     */
//    Member member() const;

    /**
      Sets the change type.




*/

#include <qstring.h>
#include <opensync/opensync.h>
#include <opensync/opensync-engine.h>

#include "syncmapping.h"

using namespace QSync;

SyncMapping::SyncMapping()
  : mEngine( 0 ), mMappingEngine( 0 )
{
}

SyncMapping::SyncMapping( OSyncMappingEngine *mapping, OSyncEngine *engine )
  : mEngine( engine ), mMappingEngine( mapping )
{
}



bool SyncMapping::isValid() const
{
  return ( mEngine != 0 && mMappingEngine != 0 );
}

/*
long long SyncMapping::id() const
{
  Q_ASSERT( mMappingEngine );

  return osync_mapping_engine_get_id( mMappingEngine );
}
*/

void SyncMapping::duplicate()
{
  Q_ASSERT( mEngine );
  Q_ASSERT( mMappingEngine );

  OSyncError *error = 0;

  osync_mapping_engine_duplicate( mMappingEngine, &error );
}

void SyncMapping::solve( const SyncChange &change )
{
  Q_ASSERT( mEngine );
  Q_ASSERT( mMappingEngine );
  Q_ASSERT( change.isValid() );

  OSyncError *error = 0;

  osync_mapping_engine_solve( mMappingEngine, change.mSyncChange, &error );
}

void SyncMapping::ignore()
{
  Q_ASSERT( mEngine );
  Q_ASSERT( mMappingEngine );

  //TODO: error should be returned as Result
  OSyncError *error = 0;
  osync_mapping_engine_ignore( mMappingEngine, &error );
}

int SyncMapping::changesCount() const
{
  Q_ASSERT( mMappingEngine );

  return osync_mapping_engine_num_changes( mMappingEngine );
}

SyncChange SyncMapping::changeAt( int pos )
{
  Q_ASSERT( mMappingEngine );

  if ( pos < 0 || pos >= osync_mapping_engine_num_changes( mMappingEngine ) )
    return SyncChange();

  OSyncChange *ochange = osync_mapping_engine_nth_change( mMappingEngine, pos );

  return SyncChange( ochange );
}




#include <libqopensync/syncchange.h>

class OSyncEngine;
class OSyncMappingEngine;

namespace QSync {



  public:
    SyncMapping();
    SyncMapping( OSyncMappingEngine*, OSyncEngine* );
    ~SyncMapping();

    bool isValid() const;


  private:
    OSyncEngine *mEngine;
    OSyncMappingEngine *mMappingEngine;
};

}




    Boston, MA 02110-1301, USA.
*/

#include <opensync/opensync.h>
#include <opensync/opensync-engine.h>

#include "syncupdates.h"


SyncMemberUpdate::SyncMemberUpdate( OSyncMemberUpdate *update )
{
  switch ( update->type ) {
    case OSYNC_CLIENT_EVENT_CONNECTED:
      mType = Connected;
      break;
    case OSYNC_CLIENT_EVENT_DISCONNECTED:
      mType = SentChanges;
      break;
    case MEMBER_COMMITTED_ALL:
      mType = CommittedAll;
      break;
    case MEMBER_DISCONNECTED:
      mType = Disconnected;
      break;
    case OSYNC_CLIENT_EVENT_READ:
      mType = Read; 
      break;
    case OSYNC_CLIENT_EVENT_WRITTEN:
      mType = Written;
      break;
    case OSYNC_CLIENT_EVENT_SYNC_DONE:
      mType = SyncDone;
      break;
    case OSYNC_CLIENT_EVENT_DISCOVERED:
      mType = Discovered;
      break;
    case OSYNC_CLIENT_EVENT_ERROR:
      mType = Error;
      break;
  }


SyncChangeUpdate::SyncChangeUpdate( OSyncChangeUpdate *update )
{
  switch ( update->type ) {
    case OSYNC_CHANGE_EVENT_READ:
      mType = Read;
      break;
    case CHANGE_RECEIVED_INFO:
      mType = ReceivedInfo;
      break;
    case OSYNC_CHANGE_EVENT_WRITTEN:
      mType = Written;
      break;
    case OSYNC_CHANGE_EVENT_ERROR:
      mType = Error;
      break;
    case CHANGE_RECV_ERROR:
      mType = ReceiveError;
      break;
  }


    mResult = Result( &(update->error) );

  mChange = SyncChange( update->change );
  mMember.mMember = update->member;
  mMappingId = update->mapping_id;
}


  return mChange;
}

Member SyncChangeUpdate::member() const
{
  return mMember;
}

int SyncChangeUpdate::mappingId() const

SyncMappingUpdate::SyncMappingUpdate( OSyncMappingUpdate *update, OSyncEngine *engine )
{
  switch ( update->type ) {
    case OSYNC_MAPPING_EVENT_SOLVED:
      mType = Solved;
      break;
//    case OSYNC_MAPPING_EVENT_SYNCED:
  //    mType = Synced;
    //  break;
    case OSYNC_MAPPING_EVENT_ERROR:
      mType = Error;
      break;
  }



  mWinner = update->winner;
  mMapping.mEngine = engine;

  // TODO PORTING
//  mMapping.mMapping = update->mapping;
}

SyncMappingUpdate::~SyncMappingUpdate()

SyncEngineUpdate::SyncEngineUpdate( OSyncEngineUpdate *update )
{
  switch ( update->type ) {
    case OSYNC_ENGINE_EVENT_CONNECTED:
      mType = Connected;
      break;
    case OSYNC_ENGINE_EVENT_READ:
      mType = Read;
      break;
    case OSYNC_ENGINE_EVENT_WRITTEN:
      mType = Written;
      break;
    case OSYNC_ENGINE_EVENT_DISCONNECTED: 
      mType = Disconnected;
      break;
    case OSYNC_ENGINE_EVENT_ERROR:
      mType = Error;
      break;
    case OSYNC_ENGINE_EVENT_SUCCESSFUL:
      mType = SyncSuccessful;
      break;
    case OSYNC_ENGINE_EVENT_PREV_UNCLEAN:
      mType = PrevUnclean;
      break;
    case OSYNC_ENGINE_EVENT_END_CONFLICTS:
      mType = EndConflicts;
      break;
    case OSYNC_ENGINE_EVENT_SYNC_DONE:
      mType = SyncDone;
      break;
  }

  if ( update->error )




  public:
    enum Type {
      Connected,
      SentChanges,
      CommittedAll,
      Disconnected,
      Read,
      Written,
      SyncDone,
      Discovered,
      Error
    };

    SyncMemberUpdate();


  public:
    enum Type {
      Read = 1,
      Written,
      Error
      WriteError,
      ReceiveError
    };

    SyncChangeUpdate();

    Type type() const;
    Result result() const;
    SyncChange change() const;
    Member member() const;
    int mappingId() const;

  private:
    Type mType;
    Result mResult;
    SyncChange mChange;
    Member mMember;
    int mMappingId;
};


  public:
    enum Type {
      Solved = 1,
      //Synced,
      Error
    };

    SyncMappingUpdate();


  public:
    enum Type {
      Connected = 1,
      Read,
      Written,
      Disconnected,
      Error,
      SyncSuccessful,
      PrevUnclean,
      EndConflicts,
      SyncDone
    };

    SyncEngineUpdate();




  QDomDocument doc;
  doc.setContent( xml );
  QDomElement docElement = doc.documentElement();

  QDomNode node;
  for ( node = docElement.firstChild(); !node.isNull(); node = node.nextSibling() ) {
    QDomElement e = node.toElement();
    if ( e.tagName() == "directory" ) {
      QDomNode subNode;
      for ( subNode = e.firstChild(); !subNode.isNull(); subNode = subNode.nextSibling() ) {
        QDomElement subElement = subNode.toElement();
        if ( subElement.tagName() == "path" ) {
          mFilename->setURL( subElement.text() );
        } else if ( subElement.tagName() == "recursive" ) {
          mRecursive->setChecked( subElement.text() == "TRUE" );
        }
      }
    }
  }
}

QString ConfigGuiFile::save() const
{
  QString xml;
  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;
}

Lines 121-127 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/configguisyncmlhttp.cpp (-2 / +2 lines)
121	mGridLayout->addWidget( label, 5, 0 );	121	mGridLayout->addWidget( label, 5, 0 );
122		122
123	mRecvLimit = new QSpinBox( optionWidget );	123	mRecvLimit = new QSpinBox( optionWidget );
124	mRecvLimit->setMinValue( 1 );	124	mRecvLimit->setMinValue( 0 );
125	mRecvLimit->setMaxValue( 65536 );	125	mRecvLimit->setMaxValue( 65536 );
126	mGridLayout->addWidget( mRecvLimit, 5, 1 );	126	mGridLayout->addWidget( mRecvLimit, 5, 1 );
127		127
Lines 130-136 Link Here
130	mGridLayout->addWidget( label, 6, 0 );	130	mGridLayout->addWidget( label, 6, 0 );
131		131
132	mMaxObjSize = new QSpinBox( optionWidget );	132	mMaxObjSize = new QSpinBox( optionWidget );
133	mMaxObjSize->setMinValue( 1 );	133	mMaxObjSize->setMinValue( 0 );
134	mMaxObjSize->setMaxValue( 65536 );	134	mMaxObjSize->setMaxValue( 65536 );
135	mGridLayout->addWidget( mMaxObjSize, 6, 1 );	135	mGridLayout->addWidget( mMaxObjSize, 6, 1 );
136		136

Lines 153-159 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/configguisyncmlobex.cpp (-2 / +2 lines)
153	mGridLayout->addWidget( label, 14, 0 );	153	mGridLayout->addWidget( label, 14, 0 );
154		154
155	mRecvLimit = new QSpinBox( optionsWidget );	155	mRecvLimit = new QSpinBox( optionsWidget );
156	mRecvLimit->setMinValue( 1 );	156	mRecvLimit->setMinValue( 0 );
157	mRecvLimit->setMaxValue( 65536 );	157	mRecvLimit->setMaxValue( 65536 );
158	mGridLayout->addWidget( mRecvLimit, 14, 1 );	158	mGridLayout->addWidget( mRecvLimit, 14, 1 );
159		159
Lines 162-168 Link Here
162	mGridLayout->addWidget( label, 15, 0 );	162	mGridLayout->addWidget( label, 15, 0 );
163		163
164	mMaxObjSize = new QSpinBox( optionsWidget );	164	mMaxObjSize = new QSpinBox( optionsWidget );
165	mMaxObjSize->setMinValue( 1 );	165	mMaxObjSize->setMinValue( 0 );
166	mMaxObjSize->setMaxValue( 65536 );	166	mMaxObjSize->setMaxValue( 65536 );
167	mGridLayout->addWidget( mMaxObjSize, 15, 1 );	167	mGridLayout->addWidget( mMaxObjSize, 15, 1 );
168		168




#include <qcheckbox.h>

#include <libqopensync/group.h>
//#include <libqopensync/conversion.h>
#include <libqopensync/environment.h>

#include "syncprocess.h"
#include "syncprocessmanager.h"

#include "groupconfigcommon.h"

// TODO: port ObjectTypeSelector to ported solution of Conversation class
#if 0
ObjectTypeSelector::ObjectTypeSelector( QWidget *parent )
  : QWidget( parent )
{

  QSync::GroupConfig config = group.config();
  config.setActiveObjectTypes( objectTypes );
}
#endif

GroupConfigCommon::GroupConfigCommon( QWidget *parent )
  : QWidget( parent )

  mGroupName = new KLineEdit( this );
  layout->addWidget( mGroupName, 0, 1 );

  //layout->addWidget( new QLabel( i18n( "Object Types to be Synchronized:"), this ), 1, 0, Qt::AlignTop );

  // TODO port ObjectTypeSelector class..
  //mObjectTypeSelector = new ObjectTypeSelector( this );
  //layout->addWidget( mObjectTypeSelector, 1, 1 );

  layout->setRowStretch( 2, 1 );
}

  mSyncProcess = syncProcess;

  mGroupName->setText( mSyncProcess->group().name() );

  // TODO port ObjectTypeSelector class..
  //mObjectTypeSelector->load( mSyncProcess->group() );
}

void GroupConfigCommon::save()
{
  mSyncProcess->group().setName( mGroupName->text() );

  // TODO port ObjectTypeSelector class..
  //mObjectTypeSelector->save( mSyncProcess->group() );
}

Lines 30-35 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/groupconfigcommon.h (-1 / +4 lines)
30	class SyncProcess;	30	class SyncProcess;
31	class QCheckBox;	31	class QCheckBox;
32		32
		33	//TODO: Conversation needs to be ported before...
		34	#if 0
33	class ObjectTypeSelector : public QWidget	35	class ObjectTypeSelector : public QWidget
34	{	36	{
35	public:	37	public:
Lines 41-46 Link Here
41	private:	43	private:
42	QMap<QString,QCheckBox *> mObjectTypeChecks;	44	QMap<QString,QCheckBox *> mObjectTypeChecks;
43	};	45	};
		46	#endif
44		47
45	class GroupConfigCommon : public QWidget	48	class GroupConfigCommon : public QWidget
46	{	49	{
Lines 52-58 Link Here
52		55
53	private:	56	private:
54	KLineEdit *mGroupName;	57	KLineEdit *mGroupName;
55	ObjectTypeSelector *mObjectTypeSelector;	58	// ObjectTypeSelector *mObjectTypeSelector;
56		59
57	SyncProcess *mSyncProcess;	60	SyncProcess *mSyncProcess;
58	};	61	};




#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>

#include <qlabel.h>
#include <qlayout.h>
#include <qpushbutton.h>
#include <qtimer.h>

GroupConfig::GroupConfig( QWidget *parent )
  : QWidget( parent )

  mMemberView = new KJanusWidget( this, 0, KJanusWidget::IconList );
  topLayout->addWidget( mMemberView );

  QBoxLayout *buttonLayout = new QHBoxLayout( topLayout );

  QPushButton *addButton = new QPushButton( i18n("Add Member..."), this );
  connect( addButton, SIGNAL( clicked() ), SLOT( addMember() ) );
  buttonLayout->addWidget( addButton );

  buttonLayout->addStretch( 1 );

  icon = KGlobal::iconLoader()->loadIcon( "bookmark", KIcon::Desktop );
  QFrame *page = mMemberView->addPage( i18n("Group"),
    i18n("General Group Settings"), icon );


  mCommonConfig = new GroupConfigCommon( page );
  pageLayout->addWidget( mCommonConfig );

  connect( mMemberView, SIGNAL( aboutToShowPage( QWidget* ) ), SLOT( memberWidgetSelected( QWidget* ) ) );
}

void GroupConfig::setSyncProcess( SyncProcess *process )


void GroupConfig::updateMembers()
{
  QMap<QWidget*, MemberConfig *>::ConstIterator memberIt;
  for ( memberIt = mMemberConfigs.begin(); memberIt != mMemberConfigs.end(); ++memberIt )
    memberIt.data()->saveData();

  QValueList<QFrame *>::ConstIterator it2;
  for ( it2 = mConfigPages.begin(); it2 != mConfigPages.end(); ++it2 ) {

  mConfigPages.clear();
  mMemberConfigs.clear();

  const QSync::Group group = mProcess->group();
  for ( int i = 0; i < group.memberCount(); ++i ) {
    QSync::Member member = group.memberAt( i );
    QSync::Member member = *it;
    MemberInfo mi( member );
    QFrame *page = mMemberView->addPage( mi.name(), 
      QString( "%1 (%2)" ).arg( mi.name() ).arg(member.pluginName()), mi.desktopIcon() );

    mConfigPages.append( page );

    MemberConfig *memberConfig = new MemberConfig( page, member );
    mMemberConfigs.insert( page, memberConfig );
    pageLayout->addWidget( memberConfig );

    memberConfig->loadData();

{
  mProcess->group().save();

  QMap<QWidget*, MemberConfig*>::ConstIterator it;
  for ( it = mMemberConfigs.begin(); it != mMemberConfigs.end(); ++it )
    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( QWidget *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 );

  }
}

void GroupConfig::removeMember()
{
  QWidget *selectedWidget = mMemberView->pageWidget( mMemberView->activePageIndex() );
  if ( selectedWidget && mMemberConfigs.contains( selectedWidget ) ) {
    MemberConfig *config = mMemberConfigs[ selectedWidget ];

    SyncProcessManager::self()->removeMember( mProcess, config->member() );
    mMemberConfigs.remove( selectedWidget );

    QTimer::singleShot( 0, this, SLOT( updateMembers() ) );
  }
}

#include "groupconfig.moc"

Lines 28-34 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/groupconfigdialog.cpp (-1 / +23 lines)
28		28
29	GroupConfigDialog::GroupConfigDialog( QWidget parent, SyncProcess process )	29	GroupConfigDialog::GroupConfigDialog( QWidget parent, SyncProcess process )
30	: KDialogBase( parent, 0, true, i18n("Configure Synchronization Group"),	30	: KDialogBase( parent, 0, true, i18n("Configure Synchronization Group"),
31	Ok )	31	Ok \| User1 \| User2, Ok )
32	{	32	{
33	QFrame *topFrame = makeMainWidget();	33	QFrame *topFrame = makeMainWidget();
34		34
Lines 40-45 Link Here
40	mConfigWidget->setSyncProcess( process );	40	mConfigWidget->setSyncProcess( process );
41		41
42	setInitialSize( configDialogSize( "size_groupconfigdialog" ) );	42	setInitialSize( configDialogSize( "size_groupconfigdialog" ) );
		43
		44	enableButton( User1, false );
		45	setButtonText( User1, i18n( "Remove Member" ) );
		46
		47	connect( mConfigWidget, SIGNAL( memberSelected( bool ) ), SLOT( memberSelected( bool ) ) );
		48
		49	setButtonText( User2, i18n("Add Member...") );
43	}	50	}
44		51
45	GroupConfigDialog::~GroupConfigDialog()	52	GroupConfigDialog::~GroupConfigDialog()
Lines 54-57 Link Here
54	accept();	61	accept();
55	}	62	}
56		63
		64	void GroupConfigDialog::slotUser1()
		65	{
		66	mConfigWidget->removeMember();
		67	}
		68
		69	void GroupConfigDialog::slotUser2()
		70	{
		71	mConfigWidget->addMember();
		72	}
		73
		74	void GroupConfigDialog::memberSelected( bool selected )
		75	{
		76	enableButton( User1, selected );
		77	}
		78
57	#include "groupconfigdialog.moc"	79	#include "groupconfigdialog.moc"

Lines 35-40 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/groupconfigdialog.h (+5 lines)
35		35
36	protected slots:	36	protected slots:
37	void slotOk();	37	void slotOk();
		38	void slotUser1();
		39	void slotUser2();
		40
		41	private slots:
		42	void memberSelected( bool );
38		43
39	private:	44	private:
40	GroupConfig *mConfigWidget;	45	GroupConfig *mConfigWidget;





    void setSyncProcess( SyncProcess *process );

    void saveConfig();

  public slots:
    void addMember();
    void removeMember();

    void updateMembers();

  signals:
    void memberSelected( bool );

  protected slots:
    void memberWidgetSelected( QWidget* );

  private:
    QLabel *mNameLabel;

    SyncProcess *mProcess;

    GroupConfigCommon *mCommonConfig;
    QMap<QWidget*, MemberConfig*> mMemberConfigs;
    QValueList<QFrame*> mConfigPages;
};

#endif

Lines 33-38 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/groupitem.cpp (-40 / +31 lines)
33	#include <qprogressbar.h>	33	#include <qprogressbar.h>
34	#include <qvbox.h>	34	#include <qvbox.h>
35		35
		36	#include <libqopensync/plugin.h>
		37	#include <libqopensync/pluginenv.h>
		38
36	#include "memberinfo.h"	39	#include "memberinfo.h"
37	#include "multiconflictdialog.h"	40	#include "multiconflictdialog.h"
38	#include "singleconflictdialog.h"	41	#include "singleconflictdialog.h"
Lines 150-161 Link Here
150	mProgressBar->reset();	153	mProgressBar->reset();
151	mProgressBar->hide();	154	mProgressBar->hide();
152		155
153	QSync::Group group = mSyncProcess->group();	156	const QSync::Group group = mSyncProcess->group();
154	QSync::Group::Iterator memberIt( group.begin() );	157	for ( int i = 0; i < group.memberCount(); ++i ) {
155	QSync::Group::Iterator memberEndIt( group.end() );	158	MemberItem *item = new MemberItem( mBox, mSyncProcess, group.memberAt( i ) );
156
157	for ( ; memberIt != memberEndIt; ++memberIt ) {
158	MemberItem item = new MemberItem( mBox, mSyncProcess, memberIt );
159	item->show();	159	item->show();
160	item->setStatusMessage( i18n( "Ready" ) );	160	item->setStatusMessage( i18n( "Ready" ) );
161	mMemberItems.append( item );	161	mMemberItems.append( item );
Lines 187-200 Link Here
187	void GroupItem::change( const QSync::SyncChangeUpdate &update )	187	void GroupItem::change( const QSync::SyncChangeUpdate &update )
188	{	188	{
189	switch ( update.type() ) {	189	switch ( update.type() ) {
190	case QSync::SyncChangeUpdate::Received:	190	case QSync::SyncChangeUpdate::Read:
191	mProcessedItems++;	191	mProcessedItems++;
192	mStatus->setText( i18n( "%1 entries read" ).arg( mProcessedItems ) );	192	mStatus->setText( i18n( "%1 entries read" ).arg( mProcessedItems ) );
193	break;	193	break;
194	case QSync::SyncChangeUpdate::ReceivedInfo:	194	case QSync::SyncChangeUpdate::Written:
195	mStatus->setText( i18n( "Receive information" ) );
196	break;
197	case QSync::SyncChangeUpdate::Sent:
198	mProcessedItems--;	195	mProcessedItems--;
199	mStatus->setText( i18n( "%1 entries written" ).arg( mMaxProcessedItems - mProcessedItems ) );	196	mStatus->setText( i18n( "%1 entries written" ).arg( mMaxProcessedItems - mProcessedItems ) );
200		197
Lines 211-221 Link Here
211	mProgressBar->setProgress( 100 - progress );	208	mProgressBar->setProgress( 100 - progress );
212	}	209	}
213	break;	210	break;
214	case QSync::SyncChangeUpdate::WriteError:	211	case QSync::SyncChangeUpdate::Error:
215	mStatus->setText( i18n( "Error" ) );
216	KPassivePopup::message( update.result().message(), this );
217	break;
218	case QSync::SyncChangeUpdate::ReceiveError:
219	mStatus->setText( i18n( "Error" ) );	212	mStatus->setText( i18n( "Error" ) );
220	KPassivePopup::message( update.result().message(), this );	213	KPassivePopup::message( update.result().message(), this );
221	break;	214	break;
Lines 232-252 Link Here
232	void GroupItem::engine( const QSync::SyncEngineUpdate &update )	225	void GroupItem::engine( const QSync::SyncEngineUpdate &update )
233	{	226	{
234	switch ( update.type() ) {	227	switch ( update.type() ) {
235	case QSync::SyncEngineUpdate::EndPhaseConnected:	228	case QSync::SyncEngineUpdate::Connected:
236	mStatus->setText( i18n( "Connected" ) );	229	mStatus->setText( i18n( "Connected" ) );
237	mProgressBar->setProgress( 0 );	230	mProgressBar->setProgress( 0 );
238	mSynchronizing = true;	231	mSynchronizing = true;
239	mSyncAction->setText( "Abort Synchronization" );	232	mSyncAction->setText( "Abort Synchronization" );
240	break;	233	break;
241	case QSync::SyncEngineUpdate::EndPhaseRead:	234	case QSync::SyncEngineUpdate::Read:
242	mStatus->setText( i18n( "Data read" ) );	235	mStatus->setText( i18n( "Data read" ) );
243	break;	236	break;
244	case QSync::SyncEngineUpdate::EndPhaseWrite:	237	case QSync::SyncEngineUpdate::Written:
245	mStatus->setText( i18n( "Data written" ) );	238	mStatus->setText( i18n( "Data written" ) );
246	mProgressBar->setProgress( 100 );	239	mProgressBar->setProgress( 100 );
247	mProcessedItems = mMaxProcessedItems = 0;	240	mProcessedItems = mMaxProcessedItems = 0;
248	break;	241	break;
249	case QSync::SyncEngineUpdate::EndPhaseDisconnected:	242	case QSync::SyncEngineUpdate::Disconnected:
250	mStatus->setText( i18n( "Disconnected" ) );	243	mStatus->setText( i18n( "Disconnected" ) );
251	break;	244	break;
252	case QSync::SyncEngineUpdate::Error:	245	case QSync::SyncEngineUpdate::Error:
Lines 257-263 Link Here
257	mSynchronizing = false;	250	mSynchronizing = false;
258	mSyncAction->setText( i18n( "Synchronize Now" ) );	251	mSyncAction->setText( i18n( "Synchronize Now" ) );
259	break;	252	break;
260	case QSync::SyncEngineUpdate::SyncSuccessfull:	253	case QSync::SyncEngineUpdate::SyncSuccessful:
261	mStatus->setText( i18n( "Successfully synchronized" ) );	254	mStatus->setText( i18n( "Successfully synchronized" ) );
262	mSyncProcess->group().setLastSynchronization( QDateTime::currentDateTime() );	255	mSyncProcess->group().setLastSynchronization( QDateTime::currentDateTime() );
263	mSyncProcess->group().save();	256	mSyncProcess->group().save();
Lines 288-315 Link Here
288	case QSync::SyncMemberUpdate::Connected:	281	case QSync::SyncMemberUpdate::Connected:
289	(*it)->setStatusMessage( i18n( "Connected" ) );	282	(*it)->setStatusMessage( i18n( "Connected" ) );
290	break;	283	break;
291	case QSync::SyncMemberUpdate::SentChanges:	284	case QSync::SyncMemberUpdate::Read:
292	(*it)->setStatusMessage( i18n( "Changes read" ) );	285	(*it)->setStatusMessage( i18n( "Changes read" ) );
293	break;	286	break;
294	case QSync::SyncMemberUpdate::CommittedAll:	287	case QSync::SyncMemberUpdate::Written:
295	(*it)->setStatusMessage( i18n( "Changes written" ) );	288	(*it)->setStatusMessage( i18n( "Changes written" ) );
296	break;	289	break;
297	case QSync::SyncMemberUpdate::Disconnected:	290	case QSync::SyncMemberUpdate::Disconnected:
298	(*it)->setStatusMessage( i18n( "Disconnected" ) );	291	(*it)->setStatusMessage( i18n( "Disconnected" ) );
299	break;	292	break;
300	case QSync::SyncMemberUpdate::ConnectError:	293	case QSync::SyncMemberUpdate::SyncDone:
301	(*it)->setStatusMessage( i18n( "Error: %1" ).arg( update.result().message() ) );	294	(*it)->setStatusMessage( i18n( "Synchronization done" ) );
302	break;	295	break;
303	case QSync::SyncMemberUpdate::GetChangesError:	296	case QSync::SyncMemberUpdate::Discovered:
304	(*it)->setStatusMessage( i18n( "Error: %1" ).arg( update.result().message() ) );	297	(*it)->setStatusMessage( i18n( "Discovered" ) );
305	break;	298	break;
306	case QSync::SyncMemberUpdate::CommittedAllError:	299	case QSync::SyncMemberUpdate::Error:
307	(*it)->setStatusMessage( i18n( "Error: %1" ).arg( update.result().message() ) );
308	break;
309	case QSync::SyncMemberUpdate::SyncDoneError:
310	(*it)->setStatusMessage( i18n( "Error: %1" ).arg( update.result().message() ) );
311	break;
312	case QSync::SyncMemberUpdate::DisconnectedError:
313	(*it)->setStatusMessage( i18n( "Error: %1" ).arg( update.result().message() ) );	300	(*it)->setStatusMessage( i18n( "Error: %1" ).arg( update.result().message() ) );
314	break;	301	break;
315	default:	302	default:
Lines 352-362 Link Here
352	QFont boldFont;	339	QFont boldFont;
353	boldFont.setBold( true );	340	boldFont.setBold( true );
354		341
355	MemberInfo mi( member );	342	const MemberInfo mi( member );
356		343	const QPixmap icon = mi.smallIcon();
357	QPixmap icon = mi.smallIcon();
358
359	QSync::Plugin plugin = member.plugin();
360		344
361	QVBoxLayout *layout = new QVBoxLayout( this );	345	QVBoxLayout *layout = new QVBoxLayout( this );
362		346
Lines 378-384 Link Here
378	mStatus = new QLabel( box );	362	mStatus = new QLabel( box );
379		363
380	mMemberName->setText( member.name() );	364	mMemberName->setText( member.name() );
381	mDescription->setText( plugin.longName() );	365
		366	const QSync::PluginEnv *env = SyncProcessManager::self()->pluginEnv();
		367	const QSync::Plugin plugin = env->pluginByName( member.pluginName() );
		368
		369	if ( plugin.isValid() )
		370	mDescription->setText( plugin.longName() );
		371	else
		372	mDescription->setText( i18n("Plugin \"%1\" can't get initialized!").arg( member.pluginName() ) );
382	}	373	}
383		374
384	void MemberItem::setStatusMessage( const QString &msg )	375	void MemberItem::setStatusMessage( const QString &msg )

Lines 2-7 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/kitchensync.desktop (+1 lines)
2	Encoding=UTF-8	2	Encoding=UTF-8
3	Name=KitchenSync	3	Name=KitchenSync
4	Name[pt]=KitchenSyncFilter	4	Name[pt]=KitchenSyncFilter
		5	Name[pt_BR]=KitchenSyncFilter
5	Name[sv]=Kitchensync	6	Name[sv]=Kitchensync
6	GenericName=Synchronization	7	GenericName=Synchronization
7	GenericName[af]=Sinkronisasie	8	GenericName[af]=Sinkronisasie




#include "syncprocess.h"
#include "syncprocessmanager.h"

#include <libqopensync/result.h>

#include <kaboutdata.h>
#include <kaction.h>

  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(), SIGNAL( changed() ),

{
  bool ok;
  QString name = KInputDialog::getText( i18n("Create Synchronization Group"),
    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();

    process = SyncProcessManager::self()->byGroupName( name );
    if ( process )
      editGroup( process );
  }

Lines 24-30 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/Makefile.am (-1 / +1 lines)
24	pluginpicker.cpp configgui.cpp configguiblank.cpp configguifile.cpp \	24	pluginpicker.cpp configgui.cpp configguiblank.cpp configguifile.cpp \
25	memberinfo.cpp groupconfigcommon.cpp kwidgetlist.cpp \	25	memberinfo.cpp groupconfigcommon.cpp kwidgetlist.cpp \
26	configguipalm.cpp conflictdialog.cpp singleconflictdialog.cpp \	26	configguipalm.cpp conflictdialog.cpp singleconflictdialog.cpp \
27	addresseediffalgo.cpp calendardiffalgo.cpp \	27	addresseediffalgo.cpp calendardiffalgo.cpp xmldiffalgo.cpp \
28	htmldiffalgodisplay.cpp genericdiffalgo.cpp multiconflictdialog.cpp \	28	htmldiffalgodisplay.cpp genericdiffalgo.cpp multiconflictdialog.cpp \
29	configguiirmc.cpp \	29	configguiirmc.cpp \
30	configguisyncmlobex.cpp configguisyncmlhttp.cpp configguiopie.cpp \	30	configguisyncmlobex.cpp configguisyncmlhttp.cpp configguiopie.cpp \

Lines 23-28 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/memberconfig.cpp (-3 / +8 lines)
23	#include "configgui.h"	23	#include "configgui.h"
24	#include "memberinfo.h"	24	#include "memberinfo.h"
25		25
		26	#include <libqopensync/result.h>
		27
26	#include <klocale.h>	28	#include <klocale.h>
27	#include <kmessagebox.h>	29	#include <kmessagebox.h>
28		30
Lines 67-79 Link Here
67	if ( txt.isEmpty() ) {	69	if ( txt.isEmpty() ) {
68	KMessageBox::sorry( this, i18n("Configuration of %1 is empty.").arg( mMember.pluginName() ) );	70	KMessageBox::sorry( this, i18n("Configuration of %1 is empty.").arg( mMember.pluginName() ) );
69	} else {	71	} else {
70	QByteArray cfg = txt.utf8();	72	mMember.setConfiguration( txt.utf8() );
71	cfg.truncate(cfg.size() - 1); /* discard NUL terminator */
72	mMember.setConfiguration( cfg );
73	mMember.setName( mGui->instanceName() );	73	mMember.setName( mGui->instanceName() );
74	// TODO: Check for save() error.	74	// TODO: Check for save() error.
75	mMember.save();	75	mMember.save();
76	}	76	}
77	}	77	}
78		78
		79	QSync::Member MemberConfig::member() const
		80	{
		81	return mMember;
		82	}
		83
79	#include "memberconfig.moc"	84	#include "memberconfig.moc"

Lines 38-43 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/memberconfig.h (+2 lines)
38	void loadData();	38	void loadData();
39	void saveData();	39	void saveData();
40		40
		41	QSync::Member member() const;
		42
41	private:	43	private:
42	QSync::Member mMember;	44	QSync::Member mMember;
43		45

Lines 39-46 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/multiconflictdialog.cpp (-2 / +4 lines)
39	{	39	{
40	QGridLayout *layout = new QGridLayout( this, 2, 1, KDialog::marginHint(), KDialog::spacingHint() );	40	QGridLayout *layout = new QGridLayout( this, 2, 1, KDialog::marginHint(), KDialog::spacingHint() );
41		41
42	MemberInfo mi( change.member() );	42	// TODO change doesn't contain member as struct member .. use SyncMapping to determine the correct member.
43	layout->addWidget( new QLabel( mi.name(), this ), 0, 0 );	43	//MemberInfo mi( change.member() );
		44	//layout->addWidget( new QLabel( mi.name(), this ), 0, 0 );
		45	layout->addWidget( new QLabel( "PORTING TODO", this ), 0, 0 );
44		46
45	QString type;	47	QString type;
46	switch ( change.changeType() ) {	48	switch ( change.changeType() ) {




#include "memberinfo.h"
#include "syncprocessmanager.h"

#include <libqopensync/pluginenv.h>

#include <kdialog.h>
#include <kglobal.h>

{
  mPluginList->clear();

  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 ) );
  }
}


Lines 27-32 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/singleconflictdialog.cpp (-3 / +11 lines)
27		27
28	#include "addresseediffalgo.h"	28	#include "addresseediffalgo.h"
29	#include "genericdiffalgo.h"	29	#include "genericdiffalgo.h"
		30	#include "xmldiffalgo.h"
30	#include "htmldiffalgodisplay.h"	31	#include "htmldiffalgodisplay.h"
31	#include "memberinfo.h"	32	#include "memberinfo.h"
32		33
Lines 43-58 Link Here
43		44
44	if ( format == "file" ) {	45	if ( format == "file" ) {
45	mDiffAlgo = new KSync::GenericDiffAlgo( leftChange.data(), rightChange.data() );	46	mDiffAlgo = new KSync::GenericDiffAlgo( leftChange.data(), rightChange.data() );
46	} else if ( format == "vcard" ) {	47	} else if ( format == "vcard21" \|\| format == "vcard30" ) {
47	} else if ( format == "calendar" ) {
48	} else if ( format == "xml-contact" ) {
49	mDiffAlgo = new KSync::AddresseeDiffAlgo( leftChange.data(), rightChange.data() );	48	mDiffAlgo = new KSync::AddresseeDiffAlgo( leftChange.data(), rightChange.data() );
		49	} else if ( format == "calendar" ) {
		50	} else if ( format == "xmlformat-contact" \|\| format == "xmlformat-note"
		51	\|\| format == "xmlformat-event" \|\| format == "xmlformat-todo") {
		52	mDiffAlgo = new KSync::XmlDiffAlgo( leftChange.data(), rightChange.data() );
50	}	53	}
51		54
		55	// TODO: SyncChange doesn't have member as struct member anymore ...
		56	// Use SyncMapping to determine the member .. see msynctool for example implementation of conlicthandler
		57	#if 0
52	MemberInfo miLeft( leftChange.member() );	58	MemberInfo miLeft( leftChange.member() );
53	mDiffAlgoDisplay->setLeftSourceTitle( miLeft.name() );	59	mDiffAlgoDisplay->setLeftSourceTitle( miLeft.name() );
54	MemberInfo miRight( rightChange.member() );	60	MemberInfo miRight( rightChange.member() );
55	mDiffAlgoDisplay->setRightSourceTitle( miRight.name() );	61	mDiffAlgoDisplay->setRightSourceTitle( miRight.name() );
		62	#endif
56		63
57	if ( mDiffAlgo ) {	64	if ( mDiffAlgo ) {
58	mDiffAlgo->addDisplay( mDiffAlgoDisplay );	65	mDiffAlgo->addDisplay( mDiffAlgoDisplay );
Lines 99-104 Link Here
99	QGridLayout *layout = new QGridLayout( this, 3, 4, KDialog::marginHint(), KDialog::spacingHint() );	106	QGridLayout *layout = new QGridLayout( this, 3, 4, KDialog::marginHint(), KDialog::spacingHint() );
100		107
101	layout->addMultiCellWidget( new QLabel( i18n( "A conflict has appeared, please solve it manually." ), this ), 0, 0, 0, 3 );	108	layout->addMultiCellWidget( new QLabel( i18n( "A conflict has appeared, please solve it manually." ), this ), 0, 0, 0, 3 );
		109
102	mDiffAlgoDisplay = new KSync::HTMLDiffAlgoDisplay( this );	110	mDiffAlgoDisplay = new KSync::HTMLDiffAlgoDisplay( this );
103		111
104	layout->addMultiCellWidget( mDiffAlgoDisplay, 1, 1, 0, 3 );	112	layout->addMultiCellWidget( mDiffAlgoDisplay, 1, 1, 0, 3 );




*/

#include <libqopensync/engine.h>
#include <libqopensync/member.h>
#include <libqopensync/result.h>

#include <kdebug.h>
#include <klocale.h>
#include <kmessagebox.h>

#include "syncprocess.h"
#include "syncprocessmanager.h"


QSync::Result SyncProcess::addMember( const QSync::Plugin &plugin )
{
  QSync::Member member = mGroup.addMember( plugin );
  QSync::Result result = member.instance();

  if ( !result.isError() )
    mGroup.save();

  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() ) {
    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() ) );

  }

  emit engineChanged( mEngine );
}

void SyncProcess::applyObjectTypeFilter()
{
  const QSync::Conversion conversion = SyncProcessManager::self()->environment()->conversion();
  const QStringList objectTypes = conversion.objectTypes();
  const QStringList 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"




    QString 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 ).

Lines 23-29 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/syncprocessmanager.cpp (-14 / +34 lines)
23		23
24	#include "syncprocess.h"	24	#include "syncprocess.h"
25		25
26	#include <libqopensync/environment.h>	26	#include <libqopensync/groupenv.h>
		27	#include <libqopensync/member.h>
		28	#include <libqopensync/pluginenv.h>
		29	#include <libqopensync/result.h>
27		30
28	#include <kstaticdeleter.h>	31	#include <kstaticdeleter.h>
29	#include <kmessagebox.h>	32	#include <kmessagebox.h>
Lines 43-56 Link Here
43		46
44	SyncProcessManager::SyncProcessManager()	47	SyncProcessManager::SyncProcessManager()
45	{	48	{
46	mEnvironment = new QSync::Environment;	49	mGroupEnv = new QSync::GroupEnv;
47	QSync::Result result = mEnvironment->initialize();	50	QSync::Result result = mGroupEnv->initialize();
48	if ( result.isError() ) {	51	if ( result.isError() ) {
49	KMessageBox::error( 0, i18n("Error initializing OpenSync.\n%1")	52	KMessageBox::error( 0, i18n("Error initializing OpenSync.\n%1")
50	.arg( result.message() ) );	53	.arg( result.message() ) );
51	} else {	54	} else {
52	init( mEnvironment );	55	initGroup( mGroupEnv );
53	}	56	}
		57
		58	mPluginEnv = new QSync::PluginEnv;
		59	result = mPluginEnv->initialize();
		60	if ( result.isError() ) {
		61	KMessageBox::error( 0, i18n("Error initializing OpenSync.\n%1")
		62	.arg( result.message() ) );
		63	} else {
		64	// initPlugin( mPluginEnv );
		65	}
		66
54	}	67	}
55		68
56	SyncProcessManager::~SyncProcessManager()	69	SyncProcessManager::~SyncProcessManager()
Lines 61-68 Link Here
61		74
62	mProcesses.clear();	75	mProcesses.clear();
63		76
64	mEnvironment->finalize();	77	mGroupEnv->finalize();
65	delete mEnvironment;	78	delete mGroupEnv;
66	}	79	}
67		80
68	int SyncProcessManager::count() const	81	int SyncProcessManager::count() const
Lines 102-109 Link Here
102	{	115	{
103	SyncProcess* process = byGroupName( name );	116	SyncProcess* process = byGroupName( name );
104	if ( !process ) {	117	if ( !process ) {
105	QSync::Group group = mEnvironment->addGroup();	118	QSync::Group group = mGroupEnv->addGroup( name );
106	group.setName( name );
107	group.save();	119	group.save();
108		120
109	mProcesses.append( new SyncProcess( group ) );	121	mProcesses.append( new SyncProcess( group ) );
Lines 120-141 Link Here
120	const QSync::Group group = syncProcess->group();	132	const QSync::Group group = syncProcess->group();
121	delete syncProcess;	133	delete syncProcess;
122		134
123	mEnvironment->removeGroup( group );	135	mGroupEnv->removeGroup( group );
124		136
125	emit changed();	137	emit changed();
126	}	138	}
127	}	139	}
128		140
129	void SyncProcessManager::init( QSync::Environment *environment )	141	void SyncProcessManager::initGroup( QSync::GroupEnv *groupEnv )
130	{	142	{
131	QSync::Environment::GroupIterator it( environment->groupBegin() );	143	for ( int i = 0; i < groupEnv->groupCount(); ++i ) {
132	for ( ; it != environment->groupEnd(); ++it ) {
133	/**	144	/**
134	* We check whether the group is valid before we append them	145	* We check whether the group is valid before we append them
135	* to mProcesses. That avoids crashes if the plugin of one of	146	* to mProcesses. That avoids crashes if the plugin of one of
136	* the members isn't loaded (e.g. not installed).	147	* the members isn't loaded (e.g. not installed).
137	*/	148	*/
138	const QSync::Group group = *it;	149	const QSync::Group group = groupEnv->groupAt( i );
139	int count = group.memberCount();	150	int count = group.memberCount();
140		151
141	bool isValid = true;	152	bool isValid = true;
Lines 149-155 Link Here
149	}	160	}
150		161
151	if ( isValid )	162	if ( isValid )
152	mProcesses.append( new SyncProcess( *it ) );	163	mProcesses.append( new SyncProcess( group ) );
153	}	164	}
154		165
155	emit changed();	166	emit changed();
Lines 169-172 Link Here
169	return result;	180	return result;
170	}	181	}
171		182
		183	void SyncProcessManager::removeMember( SyncProcess *process, const QSync::Member &member )
		184	{
		185	Q_ASSERT( process );
		186
		187	process->removeMember( member );
		188	process->group().save();
		189	emit syncProcessChanged( process );
		190	}
		191
172	#include "syncprocessmanager.moc"	192	#include "syncprocessmanager.moc"

Lines 26-32 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/syncprocessmanager.h (-5 / +18 lines)
26	#include <libqopensync/group.h>	26	#include <libqopensync/group.h>
27		27
28	namespace QSync {	28	namespace QSync {
29	class Environment;	29	class GroupEnv;
		30	class PluginEnv;
30	}	31	}
31		32
32	class SyncProcess;	33	class SyncProcess;
Lines 43-51 Link Here
43	~SyncProcessManager();	44	~SyncProcessManager();
44		45
45	/**	46	/**
46	Return OpenSync Environment.	47	Return OpenSync GroupEnv.
47	*/	48	*/
48	QSync::Environment *environment() const { return mEnvironment; }	49	QSync::GroupEnv *groupEnv() const { return mGroupEnv; }
		50
		51	/**
		52	Return OpenSync PluginEnv.
		53	*/
		54	QSync::PluginEnv *pluginEnv() const { return mPluginEnv; }
49		55
50	/**	56	/**
51	Returns the number of SyncProcesses.	57	Returns the number of SyncProcesses.
Lines 82-87 Link Here
82	*/	88	*/
83	QSync::Result addMember( SyncProcess *process, const QSync::Plugin &plugin );	89	QSync::Result addMember( SyncProcess *process, const QSync::Plugin &plugin );
84		90
		91	/**
		92	Removes the @param member from the group of @param process.
		93	*/
		94	void removeMember( SyncProcess *process, const QSync::Member &member );
		95
85	signals:	96	signals:
86	void changed();	97	void changed();
87	void syncProcessChanged( SyncProcess *process );	98	void syncProcessChanged( SyncProcess *process );
Lines 89-98 Link Here
89	private:	100	private:
90	SyncProcessManager();	101	SyncProcessManager();
91		102
92	void init( QSync::Environment *environment );	103	void initGroup( QSync::GroupEnv *groupEnv );
		104	// void initPlugin( QSync::PluginEnv *pluginEnv );
93		105
94	QValueList<SyncProcess*> mProcesses;	106	QValueList<SyncProcess*> mProcesses;
95	QSync::Environment *mEnvironment;	107	QSync::GroupEnv *mGroupEnv;
		108	QSync::PluginEnv *mPluginEnv;
96		109
97	static SyncProcessManager *mSelf;	110	static SyncProcessManager *mSelf;
98	};	111	};




/*
    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 QString &left, const QString &right )
{
  if ( left.isEmpty() && right.isEmpty() )
    return true;
  else
    return left == right;
}
#endif

XmlDiffAlgo::XmlDiffAlgo( const QString &leftXml, const QString &rightXml )
{
  kdDebug() << __func__ << " " << __LINE__ << endl;

  mLeftXml.setContent( leftXml );
  mRightXml.setContent( rightXml );

}

XmlDiffAlgo::XmlDiffAlgo( const QDomDocument &leftXml, const QDomDocument &rightXml )
  : mLeftXml( leftXml ), mRightXml( rightXml )
{
  kdDebug() << __func__ << " " << __LINE__ << endl;
}

void XmlDiffAlgo::appendSingleNodes(QDomElement &element, bool isLeft)
{
  QDomNode node;

  for ( node = element.firstChild(); !node.isNull(); node = node.nextSibling() ) {
    QDomElement child = node.toElement();

    if (isLeft)
      additionalLeftField( node.nodeName(), child.text() );
    else
      additionalRightField( node.nodeName(), child.text() );
  }

}

void XmlDiffAlgo::appendConflictNodes(QDomElement &leftElement, QDomElement &rightElement)
{
  QDomNode left, right;
  QDomElement 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;

      QString 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(QDomElement &leftElement, QDomElement &rightElement)
{
  QDomNode left, right;
  QDomElement leftChild, rightChild;
  QDomNodeList 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() ) {
        QString 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();

  QDomElement leftElement = mLeftXml.documentElement();
  QDomElement rightElement = mRightXml.documentElement();

  compareNode( leftElement, rightElement );

  end();
}





/*
    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 <qdom.h>

#include <libkdepim/diffalgo.h>

using namespace KPIM;

namespace KSync {

class XmlDiffAlgo : public DiffAlgo
{
  public:
    XmlDiffAlgo( const QString &leftXml, const QString &rightXml );
    XmlDiffAlgo( const QDomDocument &leftXml, const QDomDocument &rightXml );

    void run();

  private:
    void appendConflictNodes(QDomElement &leftElement, QDomElement &rightElement);
    void appendSingleNodes(QDomElement &element, bool isLeft);


    void compareNode(QDomElement &leftElement, QDomElement &rightElement);

    QDomDocument mLeftXml;
    QDomDocument mRightXml;
};

}

#endif

Return to bug 202974

Lines 29-37 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/configure.in.in (-5 / +3 lines)
29		29
30		30
31	HAVE_OPENSYNC=0	31	HAVE_OPENSYNC=0
32	HAVE_OPENSYNC_ENGINE=0	32	PKG_CHECK_MODULES(OPENSYNC, opensync-1.0 >= 0.33, HAVE_OPENSYNC=1,HAVE_OPENSYNC=0)
33	PKG_CHECK_MODULES(OPENSYNC, opensync-1.0 >= 0.19, HAVE_OPENSYNC=1,HAVE_OPENSYNC=0)
34	PKG_CHECK_MODULES(OPENSYNCENGINE, osengine-1.0 >= 0.19, HAVE_OPENSYNC_ENGINE=1, HAVE_OPENSYNC_ENGINE=0)
35	PKG_CHECK_MODULES(LIBXML, libxml-2.0, , HAVE_OPENSYNC=0)	33	PKG_CHECK_MODULES(LIBXML, libxml-2.0, , HAVE_OPENSYNC=0)
36	PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.6, , HAVE_OPENSYNC=0)	34	PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.6, , HAVE_OPENSYNC=0)
37		35
Lines 52-60 Link Here
52	AC_SUBST(OPENSYNC_HEADERDIR)	50	AC_SUBST(OPENSYNC_HEADERDIR)
53		51
54	dnl Check if we can compile KitchenSync	52	dnl Check if we can compile KitchenSync
55	AM_CONDITIONAL(compile_kitchensync, test "$HAVE_OPENSYNC" = 1 -a "$HAVE_OPENSYNC_ENGINE" = 1)	53	AM_CONDITIONAL(compile_kitchensync, test "$HAVE_OPENSYNC" = 1)
56		54
57	if test "$HAVE_OPENSYNC" = 1 -a "$HAVE_OPENSYNC_ENGINE" = 1 ; then	55	if test "$HAVE_OPENSYNC" = 1; then
58	AC_MSG_RESULT([found])	56	AC_MSG_RESULT([found])
59	else	57	else
60	AC_MSG_RESULT([not found])	58	AC_MSG_RESULT([not found])

Lines 24-36 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/conversion.h (-3 / +3 lines)
24		24
25	#include <qstringlist.h>	25	#include <qstringlist.h>
26		26
27	class OSyncEnv;	27	class OSyncGroupEnv;
28		28
29	namespace QSync {	29	namespace QSync {
30		30
31	class Conversion	31	class Conversion
32	{	32	{
33	friend class Environment;	33	friend class PluginEnv;
34		34
35	public:	35	public:
36	Conversion();	36	Conversion();
Lines 47-53 Link Here
47	QStringList objectTypes() const;	47	QStringList objectTypes() const;
48		48
49	private:	49	private:
50	OSyncEnv *mEnvironment;	50	OSyncGroupEnv *mGroupEnv;
51	};	51	};
52		52
53	}	53	}

Lines 1-172 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/environment.cpp (-172 lines)
1	/*
2	This file is part of libqopensync.
3
4	Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
5
6	This library is free software; you can redistribute it and/or
7	modify it under the terms of the GNU Library General Public
8	License as published by the Free Software Foundation; either
9	version 2 of the License, or (at your option) any later version.
10
11	This library is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	Library General Public License for more details.
15
16	You should have received a copy of the GNU Library General Public License
17	along with this library; see the file COPYING.LIB. If not, write to
18	the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19	Boston, MA 02110-1301, USA.
20	*/
21
22	#include "environment.h"
23
24	#include <opensync/opensync.h>
25
26	using namespace QSync;
27
28	Environment::Environment()
29	{
30	mEnvironment = osync_env_new();
31	}
32
33	Environment::~Environment()
34	{
35	osync_env_free( mEnvironment );
36	}
37
38	Environment::GroupIterator Environment::groupBegin()
39	{
40	GroupIterator it( this );
41	it.mPos = 0;
42
43	return it;
44	}
45
46	Environment::GroupIterator Environment::groupEnd()
47	{
48	GroupIterator it( this );
49	it.mPos = groupCount();
50
51	return it;
52	}
53
54	Environment::PluginIterator Environment::pluginBegin()
55	{
56	PluginIterator it( this );
57	it.mPos = 0;
58
59	return it;
60	}
61
62	Environment::PluginIterator Environment::pluginEnd()
63	{
64	PluginIterator it( this );
65	it.mPos = pluginCount();
66
67	return it;
68	}
69
70	Result Environment::initialize()
71	{
72	OSyncError *error = 0;
73	if ( !osync_env_initialize( mEnvironment, &error ) )
74	return Result( &error );
75	else
76	return Result();
77	}
78
79	Result Environment::finalize()
80	{
81	OSyncError *error = 0;
82	if ( !osync_env_finalize( mEnvironment, &error ) )
83	return Result( &error);
84	else
85	return Result();
86	}
87
88	int Environment::groupCount() const
89	{
90	return osync_env_num_groups( mEnvironment );
91	}
92
93	Group Environment::groupAt( int pos ) const
94	{
95	Group group;
96
97	if ( pos < 0 \|\| pos >= groupCount() )
98	return group;
99
100	OSyncGroup *ogroup = osync_env_nth_group( mEnvironment, pos );
101	group.mGroup = ogroup;
102
103	return group;
104	}
105
106	Group Environment::groupByName( const QString &name ) const
107	{
108	Group group;
109
110	OSyncGroup *ogroup = osync_env_find_group( mEnvironment, name.latin1() );
111	if ( ogroup )
112	group.mGroup = ogroup;
113
114	return group;
115	}
116
117	Group Environment::addGroup()
118	{
119	Group group;
120
121	OSyncGroup *ogroup = osync_group_new( mEnvironment );
122	if ( ogroup )
123	group.mGroup = ogroup;
124
125	return group;
126	}
127
128	Result Environment::removeGroup( const Group &group )
129	{
130	OSyncError *error = 0;
131	if ( !osync_group_delete( group.mGroup, &error ) )
132	return Result( &error );
133	else
134	return Result();
135	}
136
137	int Environment::pluginCount() const
138	{
139	return osync_env_num_plugins( mEnvironment );
140	}
141
142	Plugin Environment::pluginAt( int pos ) const
143	{
144	Plugin plugin;
145
146	if ( pos < 0 \|\| pos >= pluginCount() )
147	return plugin;
148
149	OSyncPlugin *oplugin = osync_env_nth_plugin( mEnvironment, pos );
150	plugin.mPlugin = oplugin;
151
152	return plugin;
153	}
154
155	Plugin Environment::pluginByName( const QString &name ) const
156	{
157	Plugin plugin;
158
159	OSyncPlugin *oplugin = osync_env_find_plugin( mEnvironment, name.latin1() );
160	if ( oplugin )
161	plugin.mPlugin = oplugin;
162
163	return plugin;
164	}
165
166	Conversion Environment::conversion() const
167	{
168	Conversion conversion;
169	conversion.mEnvironment = mEnvironment;
170
171	return conversion;
172	}

Lines 25-110 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/group.cpp (-99 / +44 lines)
25	/ hack includes /	25	/ hack includes /
26		26
27	#include <opensync/opensync.h>	27	#include <opensync/opensync.h>
		28	#include <opensync/opensync-group.h>
28		29
29	#include "conversion.h"	30	#include "conversion.h"
		31	#include "filter.h"
		32	#include "member.h"
		33	#include "plugin.h"
		34	#include "result.h"
		35
30	#include "group.h"	36	#include "group.h"
31		37
32	using namespace QSync;	38	using namespace QSync;
33		39
34	/**
35	This class is a quick hack for OpenSync 0.19 and 0.20 because
36	the engine doesn't stores the filter settings itself when calling
37	osync_group_set_objtype_enabled(), so we have to store it for every
38	group in a separated config file. This class encapsulates it.
39	*/
40	GroupConfig::GroupConfig()
41	: mGroup( 0 )
42	{
43	}
44
45	QStringList GroupConfig::activeObjectTypes() const
46	{
47	Q_ASSERT( mGroup );
48
49	const QString fileName = QString( "%1/filter.conf" ).arg( osync_group_get_configdir( mGroup ) );
50
51	QFile file( fileName );
52	if ( !file.open( IO_ReadOnly ) )
53	return QStringList();
54
55	QDomDocument document;
56
57	QString message;
58	if ( !document.setContent( &file, &message ) ) {
59	qDebug( "Error on loading %s: %s", fileName.latin1(), message.latin1() );
60	return QStringList();
61	}
62	file.close();
63
64	QStringList objectTypes;
65
66	QDomElement element = document.documentElement();
67	QDomNode node = element.firstChild();
68	while ( !node.isNull() ) {
69	QDomElement childElement = node.toElement();
70	if ( !childElement.isNull() )
71	objectTypes.append( childElement.tagName() );
72
73	node = node.nextSibling();
74	}
75
76	return objectTypes;
77	}
78
79	void GroupConfig::setActiveObjectTypes( const QStringList &objectTypes )
80	{
81	Q_ASSERT( mGroup );
82
83	QDomDocument document( "Filter" );
84	document.appendChild( document.createProcessingInstruction(
85	"xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
86
87	QDomElement element = document.createElement( "filter" );
88	document.appendChild( element );
89
90	for ( uint i = 0; i < objectTypes.count(); ++i ) {
91	QDomElement entry = document.createElement( objectTypes[ i ] );
92	element.appendChild( entry );
93	}
94
95	const QString fileName = QString( "%1/filter.conf" ).arg( osync_group_get_configdir( mGroup ) );
96
97	QFile file( fileName );
98	if ( !file.open( IO_WriteOnly ) )
99	return;
100
101	QTextStream s( &file );
102	s.setEncoding( QTextStream::UnicodeUTF8 );
103	s << document.toString();
104	file.close();
105	}
106
107
108	Group::Group()	40	Group::Group()
109	: mGroup( 0 )	41	: mGroup( 0 )
110	{	42	{
Lines 119-140 Link Here
119	return ( mGroup != 0 );	51	return ( mGroup != 0 );
120	}	52	}
121		53
122	Group::Iterator Group::begin()
123	{
124	Iterator it( this );
125	it.mPos = 0;
126
127	return it;
128	}
129
130	Group::Iterator Group::end()
131	{
132	Iterator it( this );
133	it.mPos = memberCount();
134
135	return it;
136	}
137
138	void Group::setName( const QString &name )	54	void Group::setName( const QString &name )
139	{	55	{
140	Q_ASSERT( mGroup );	56	Q_ASSERT( mGroup );
Lines 188-205 Link Here
188	}	104	}
189	}	105	}
190		106
191	void Group::unlock( bool removeFile )	107	void Group::unlock()
192	{	108	{
193	Q_ASSERT( mGroup );	109	Q_ASSERT( mGroup );
194		110
195	osync_group_unlock( mGroup, removeFile );	111	osync_group_unlock( mGroup );
196	}	112	}
197		113
198	Member Group::addMember()	114	Member Group::addMember( const QSync::Plugin &plugin )
199	{	115	{
200	Q_ASSERT( mGroup );	116	Q_ASSERT( mGroup );
201		117
202	OSyncMember *omember = osync_member_new( mGroup );	118	OSyncError *error = 0;
		119
		120	OSyncMember *omember = osync_member_new( &error );
		121	osync_group_add_member( mGroup, omember );
		122	osync_member_set_pluginname( omember, plugin.name().utf8() );
203		123
204	Member member;	124	Member member;
205	member.mMember = omember;	125	member.mMember = omember;
Lines 269-274 Link Here
269	return Result();	189	return Result();
270	}	190	}
271		191
		192	void Group::setUseMerger( bool use )
		193	{
		194	Q_ASSERT( mGroup );
		195	osync_group_set_merger_enabled( mGroup, use );
		196	}
		197
		198	bool Group::useMerger() const
		199	{
		200	Q_ASSERT( mGroup );
		201	return osync_group_get_merger_enabled( mGroup );
		202	}
		203
		204	void Group::setUseConverter( bool use )
		205	{
		206	Q_ASSERT( mGroup );
		207	osync_group_set_converter_enabled( mGroup, use );
		208	}
		209
		210	bool Group::useConverter() const
		211	{
		212	Q_ASSERT( mGroup );
		213	return osync_group_get_converter_enabled( mGroup );
		214	}
		215
272	void Group::setObjectTypeEnabled( const QString &objectType, bool enabled )	216	void Group::setObjectTypeEnabled( const QString &objectType, bool enabled )
273	{	217	{
274	Q_ASSERT( mGroup );	218	Q_ASSERT( mGroup );
Lines 281-292 Link Here
281	return osync_group_objtype_enabled( mGroup, objectType.utf8() );	225	return osync_group_objtype_enabled( mGroup, objectType.utf8() );
282	}	226	}
283		227
284	GroupConfig Group::config() const	228	Result Group::cleanup() const
285	{	229	{
286	Q_ASSERT( mGroup );	230	Q_ASSERT( mGroup );
287		231
288	GroupConfig config;	232	OSyncError *error = 0;
289	config.mGroup = mGroup;	233	if ( !osync_group_delete( mGroup, &error ) )
290		234	return Result( &error );
291	return config;	235	else
		236	return Result();
292	}	237	}

Lines 25-59 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/group.h (-73 / +31 lines)
25	#include <qdatetime.h>	25	#include <qdatetime.h>
26	#include <qstringlist.h>	26	#include <qstringlist.h>
27		27
28	#include <libqopensync/filter.h>
29	#include <libqopensync/member.h>
30
31	class OSyncGroup;	28	class OSyncGroup;
32		29
33	namespace QSync {	30	namespace QSync {
34		31
		32	class Filter;
		33	class Member;
		34	class Plugin;
		35	class Result;
		36
35	/**	37	/**
36	@internal	38	@internal
37	*/	39	*/
38	class GroupConfig
39	{
40	friend class Group;
41
42	public:
43	GroupConfig();
44
45	QStringList activeObjectTypes() const;
46	void setActiveObjectTypes( const QStringList &objectTypes );
47
48	private:
49	OSyncGroup *mGroup;
50	};
51
52
53	class Group	40	class Group
54	{	41	{
55	friend class Engine;	42	friend class Engine;
56	friend class Environment;	43	friend class GroupEnv;
57		44
58	public:	45	public:
59	enum LockType	46	enum LockType
Lines 71-121 Link Here
71	*/	58	*/
72	bool isValid() const;	59	bool isValid() const;
73		60
74	class Iterator
75	{
76	friend class Group;
77
78	public:
79	Iterator( Group *group )
80	: mGroup( group ), mPos( -1 )
81	{
82	}
83
84	Iterator( const Iterator &it )
85	{
86	mGroup = it.mGroup;
87	mPos = it.mPos;
88	}
89
90	Member operator*()
91	{
92	return mGroup->memberAt( mPos );
93	}
94
95	Iterator &operator++() { mPos++; return *this; }
96	Iterator &operator++( int ) { mPos++; return *this; }
97	Iterator &operator--() { mPos--; return *this; }
98	Iterator &operator--( int ) { mPos--; return *this; }
99	bool operator==( const Iterator &it ) { return mGroup == it.mGroup && mPos == it.mPos; }
100	bool operator!=( const Iterator &it ) { return mGroup == it.mGroup && mPos != it.mPos; }
101
102	private:
103	Group *mGroup;
104	int mPos;
105	};
106
107	/**
108	Returns an iterator pointing to the first item in the member list.
109	This iterator equals end() if the member list is empty.
110	*/
111	Iterator begin();
112
113	/**
114	Returns an iterator pointing past the last item in the member list.
115	This iterator equals begin() if the member list is empty.
116	*/
117	Iterator end();
118
119	/**	61	/**
120	Sets the name of the group.	62	Sets the name of the group.
121	*/	63	*/
Lines 145-161 Link Here
145		87
146	/**	88	/**
147	Unlocks the group.	89	Unlocks the group.
148
149	@param removeFile Whether the lock file shall be removed.
150	*/	90	*/
151	void unlock( bool removeFile = true );	91	void unlock();
152		92
153	/**	93	/**
154	Adds a new member to the group.	94	Adds a new member to the group.
155		95
156	@returns the new member.	96	@returns the new member.
157	*/	97	*/
158	Member addMember();	98	Member addMember( const QSync::Plugin &plugin );
159		99
160	/**	100	/**
161	Removes a member from the group.	101	Removes a member from the group.
Lines 195-213 Link Here
195	bool isObjectTypeEnabled( const QString &objectType ) const;	135	bool isObjectTypeEnabled( const QString &objectType ) const;
196		136
197	/**	137	/**
198	Saves the configuration to hard disc.	138	Sets whether this group uses the merger for synchronization.
199	*/	139	*/
200	Result save();	140	void setUseMerger( bool use );
201		141
202	/**	142	/**
203	Returns the config object of this group.	143	Returns whether this group uses the merger for synchronization.
		144	*/
		145	bool useMerger() const;
204		146
205	Note: This method is only available for OpenSync 0.19 and 0.20.	147	/**
		148	Sets whether this group uses the converter for synchronization.
206	*/	149	*/
207	GroupConfig config() const;	150	void setUseConverter( bool use );
		151
		152	/**
		153	Returns whether this group uses the converter for synchronization.
		154	*/
		155	bool useConverter() const;
		156
		157	/**
		158	Saves the configuration to hard disc.
		159	*/
		160	Result save();
208		161
209	bool operator==( const Group &group ) const { return mGroup == group.mGroup; }	162	bool operator==( const Group &group ) const { return mGroup == group.mGroup; }
210		163
		164	/**
		165	Removes all group configurations from the hard disc.
		166	*/
		167	Result cleanup() const;
		168
211	private:	169	private:
212	OSyncGroup *mGroup;	170	OSyncGroup *mGroup;
213	};	171	};

Lines 2-17 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/Makefile.am (-4 / +8 lines)
2	-I$(top_srcdir)/kitchensync \	2	-I$(top_srcdir)/kitchensync \
3	-I$(top_srcdir) \	3	-I$(top_srcdir) \
4	$(OPENSYNC_CFLAGS) \	4	$(OPENSYNC_CFLAGS) \
5	$(OPENSYNCENGINE_CFLAGS) \	5	$(GLIB_CFLAGS) \
6	$(all_includes)	6	$(all_includes)
7		7
8	lib_LTLIBRARIES = libqopensync.la	8	lib_LTLIBRARIES = libqopensync.la
9		9
10	libqopensync_la_SOURCES = callbackhandler.cpp conversion.cpp engine.cpp environment.cpp filter.cpp group.cpp \	10	libqopensync_la_SOURCES = callbackhandler.cpp engine.cpp groupenv.cpp pluginenv.cpp filter.cpp group.cpp \
11	member.cpp plugin.cpp result.cpp syncmapping.cpp syncupdates.cpp \	11	member.cpp plugin.cpp result.cpp syncmapping.cpp syncupdates.cpp \
12	syncchange.cpp	12	syncchange.cpp
13	libqopensync_la_LDFLAGS = $(all_libraries) $(KDE_RPATH) -no-undefined	13
14	libqopensync_la_LIBADD = $(LIB_KDEUI) $(OPENSYNC_LIBS) $(OPENSYNCENGINE_LIBS)	14	# FIXME: -no-undefined break the build for some unkown reason - libopensync broken?!
		15	#libqopensync_la_LDFLAGS = $(all_libraries) $(KDE_RPATH) -no-undefined
		16	libqopensync_la_LDFLAGS = $(all_libraries) $(KDE_RPATH)
		17	libqopensync_la_LIBADD = $(LIB_KDEUI) $(OPENSYNC_LIBS)
		18
15		19
16	METASOURCES = AUTO	20	METASOURCES = AUTO
17		21

Lines 22-40 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/member.h (-9 / +12 lines)
22	#ifndef QSYNC_MEMBER_H	22	#ifndef QSYNC_MEMBER_H
23	#define QSYNC_MEMBER_H	23	#define QSYNC_MEMBER_H
24		24
25	#include <libqopensync/plugin.h>	25	#include <qstring.h>
26	#include <libqopensync/result.h>
27	#include <libqopensync/plugin.h>
28		26
29	class OSyncMember;	27	class OSyncMember;
30		28
31	namespace QSync {	29	namespace QSync {
32		30
		31	class Result;
		32
33	class Member	33	class Member
34	{	34	{
35	friend class Group;	35	friend class Group;
		36	friend class Engine;
36	friend class SyncChange;	37	friend class SyncChange;
37	friend class SyncMemberUpdate;	38	friend class SyncMemberUpdate;
		39	friend class SyncChangeUpdate;
38		40
39	public:	41	public:
40	Member();	42	Member();
Lines 56-66 Link Here
56	QString pluginName() const;	58	QString pluginName() const;
57		59
58	/**	60	/**
59	Returns the plugin, the member belongs to.
60	*/
61	Plugin plugin() const;
62
63	/**
64	Returns the id of the plugin.	61	Returns the id of the plugin.
65	*/	62	*/
66	int id() const;	63	int id() const;
Lines 102-108 Link Here
102	/**	99	/**
103	Make this member an instance of the given plugin.	100	Make this member an instance of the given plugin.
104	*/	101	*/
105	Result instance( const Plugin & );	102	Result instance();
106		103
107	bool operator==( const Member& ) const;	104	bool operator==( const Member& ) const;
108		105
Lines 119-124 Link Here
119	*/	116	*/
120	bool testConnection( const QString &configuration );	117	bool testConnection( const QString &configuration );
121		118
		119
		120	/**
		121	* Deletes the member's information from the hard disc.
		122	*/
		123	Result cleanup() const;
		124
122	private:	125	private:
123	OSyncMember *mMember;	126	OSyncMember *mMember;
124	};	127	};

Lines 25-31 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/libqopensync/syncmapping.h (-3 / +3 lines)
25	#include <libqopensync/syncchange.h>	25	#include <libqopensync/syncchange.h>
26		26
27	class OSyncEngine;	27	class OSyncEngine;
28	class OSyncMapping;	28	class OSyncMappingEngine;
29		29
30	namespace QSync {	30	namespace QSync {
31		31
Lines 35-41 Link Here
35		35
36	public:	36	public:
37	SyncMapping();	37	SyncMapping();
38	SyncMapping( OSyncMapping, OSyncEngine );	38	SyncMapping( OSyncMappingEngine, OSyncEngine );
39	~SyncMapping();	39	~SyncMapping();
40		40
41	bool isValid() const;	41	bool isValid() const;
Lines 51-57 Link Here
51		51
52	private:	52	private:
53	OSyncEngine *mEngine;	53	OSyncEngine *mEngine;
54	OSyncMapping *mMapping;	54	OSyncMappingEngine *mMappingEngine;
55	};	55	};
56		56
57	}	57	}

Lines 55-67 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/configguifile.cpp (-14 / +26 lines)
55	QDomDocument doc;	55	QDomDocument doc;
56	doc.setContent( xml );	56	doc.setContent( xml );
57	QDomElement docElement = doc.documentElement();	57	QDomElement docElement = doc.documentElement();
58	QDomNode n;	58
59	for( n = docElement.firstChild(); !n.isNull(); n = n.nextSibling() ) {	59	QDomNode node;
60	QDomElement e = n.toElement();	60	for ( node = docElement.firstChild(); !node.isNull(); node = node.nextSibling() ) {
61	if ( e.tagName() == "path" ) {	61	QDomElement e = node.toElement();
62	mFilename->setURL( e.text() );	62	if ( e.tagName() == "directory" ) {
63	} else if ( e.tagName() == "recursive" ) {	63	QDomNode subNode;
64	mRecursive->setChecked( e.text() == "TRUE" );	64	for ( subNode = e.firstChild(); !subNode.isNull(); subNode = subNode.nextSibling() ) {
		65	QDomElement subElement = subNode.toElement();
		66	if ( subElement.tagName() == "path" ) {
		67	mFilename->setURL( subElement.text() );
		68	} else if ( subElement.tagName() == "recursive" ) {
		69	mRecursive->setChecked( subElement.text() == "TRUE" );
		70	}
		71	}
65	}	72	}
66	}	73	}
67	}	74	}
Lines 69-81 Link Here
69	QString ConfigGuiFile::save() const	76	QString ConfigGuiFile::save() const
70	{	77	{
71	QString xml;	78	QString xml;
72	xml = "<config>";	79	xml = "<config>\n";
73	xml += "<path>" + mFilename->url() + "</path>";	80	xml += " <directory>\n";
74	xml += "<recursive>";	81	xml += " <path>" + mFilename->url() + "</path>\n";
75	if ( mRecursive->isChecked() ) xml += "TRUE";	82	xml += " <objtype>data</objtype>\n";
76	else xml += "FALSE";	83	xml += " <recursive>";
77	xml += "</recursive>";	84	if ( mRecursive->isChecked() )
78	xml += "</config>";	85	xml += "TRUE";
		86	else
		87	xml += "FALSE";
		88	xml += "</recursive>\n";
		89	xml += " </directory>\n";
		90	xml += "</config>\n";
79		91
80	return xml;	92	return xml;
81	}	93	}

Lines 30-43 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/groupconfigcommon.cpp (-7 / +14 lines)
30	#include <qcheckbox.h>	30	#include <qcheckbox.h>
31		31
32	#include <libqopensync/group.h>	32	#include <libqopensync/group.h>
33	#include <libqopensync/conversion.h>	33	//#include <libqopensync/conversion.h>
34	#include <libqopensync/environment.h>
35		34
36	#include "syncprocess.h"	35	#include "syncprocess.h"
37	#include "syncprocessmanager.h"	36	#include "syncprocessmanager.h"
38		37
39	#include "groupconfigcommon.h"	38	#include "groupconfigcommon.h"
40		39
		40	// TODO: port ObjectTypeSelector to ported solution of Conversation class
		41	#if 0
41	ObjectTypeSelector::ObjectTypeSelector( QWidget *parent )	42	ObjectTypeSelector::ObjectTypeSelector( QWidget *parent )
42	: QWidget( parent )	43	: QWidget( parent )
43	{	44	{
Lines 124-129 Link Here
124	QSync::GroupConfig config = group.config();	125	QSync::GroupConfig config = group.config();
125	config.setActiveObjectTypes( objectTypes );	126	config.setActiveObjectTypes( objectTypes );
126	}	127	}
		128	#endif
127		129
128	GroupConfigCommon::GroupConfigCommon( QWidget *parent )	130	GroupConfigCommon::GroupConfigCommon( QWidget *parent )
129	: QWidget( parent )	131	: QWidget( parent )
Lines 135-144 Link Here
135	mGroupName = new KLineEdit( this );	137	mGroupName = new KLineEdit( this );
136	layout->addWidget( mGroupName, 0, 1 );	138	layout->addWidget( mGroupName, 0, 1 );
137		139
138	layout->addWidget( new QLabel( i18n( "Object Types to be Synchronized:"), this ), 1, 0, Qt::AlignTop );	140	//layout->addWidget( new QLabel( i18n( "Object Types to be Synchronized:"), this ), 1, 0, Qt::AlignTop );
139		141
140	mObjectTypeSelector = new ObjectTypeSelector( this );	142	// TODO port ObjectTypeSelector class..
141	layout->addWidget( mObjectTypeSelector, 1, 1 );	143	//mObjectTypeSelector = new ObjectTypeSelector( this );
		144	//layout->addWidget( mObjectTypeSelector, 1, 1 );
142		145
143	layout->setRowStretch( 2, 1 );	146	layout->setRowStretch( 2, 1 );
144	}	147	}
Lines 148-158 Link Here
148	mSyncProcess = syncProcess;	151	mSyncProcess = syncProcess;
149		152
150	mGroupName->setText( mSyncProcess->group().name() );	153	mGroupName->setText( mSyncProcess->group().name() );
151	mObjectTypeSelector->load( mSyncProcess->group() );	154
		155	// TODO port ObjectTypeSelector class..
		156	//mObjectTypeSelector->load( mSyncProcess->group() );
152	}	157	}
153		158
154	void GroupConfigCommon::save()	159	void GroupConfigCommon::save()
155	{	160	{
156	mSyncProcess->group().setName( mGroupName->text() );	161	mSyncProcess->group().setName( mGroupName->text() );
157	mObjectTypeSelector->save( mSyncProcess->group() );	162
		163	// TODO port ObjectTypeSelector class..
		164	//mObjectTypeSelector->save( mSyncProcess->group() );
158	}	165	}

Lines 40-51 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/groupconfig.h (-4 / +11 lines)
40		40
41	void setSyncProcess( SyncProcess *process );	41	void setSyncProcess( SyncProcess *process );
42		42
		43	void saveConfig();
		44
		45	public slots:
		46	void addMember();
		47	void removeMember();
		48
43	void updateMembers();	49	void updateMembers();
44		50
45	void saveConfig();	51	signals:
		52	void memberSelected( bool );
46		53
47	protected slots:	54	protected slots:
48	void addMember();	55	void memberWidgetSelected( QWidget* );
49		56
50	private:	57	private:
51	QLabel *mNameLabel;	58	QLabel *mNameLabel;
Lines 55-62 Link Here
55	SyncProcess *mProcess;	62	SyncProcess *mProcess;
56		63
57	GroupConfigCommon *mCommonConfig;	64	GroupConfigCommon *mCommonConfig;
58	QValueList<MemberConfig *> mMemberConfigs;	65	QMap<QWidget, MemberConfig> mMemberConfigs;
59	QValueList<QFrame *> mConfigPages;	66	QValueList<QFrame*> mConfigPages;
60	};	67	};
61		68
62	#endif	69	#endif

Lines 19-28 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/syncprocess.cpp (-27 / +16 lines)
19	*/	19	*/
20		20
21	#include <libqopensync/engine.h>	21	#include <libqopensync/engine.h>
22	#include <libqopensync/environment.h>	22	#include <libqopensync/member.h>
		23	#include <libqopensync/result.h>
23		24
24	#include <kdebug.h>	25	#include <kdebug.h>
25	#include <klocale.h>	26	#include <klocale.h>
		27	#include <kmessagebox.h>
26		28
27	#include "syncprocess.h"	29	#include "syncprocess.h"
28	#include "syncprocessmanager.h"	30	#include "syncprocessmanager.h"
Lines 60-67 Link Here
60		62
61	QSync::Result SyncProcess::addMember( const QSync::Plugin &plugin )	63	QSync::Result SyncProcess::addMember( const QSync::Plugin &plugin )
62	{	64	{
63	QSync::Member member = mGroup.addMember();	65	QSync::Member member = mGroup.addMember( plugin );
64	QSync::Result result = member.instance( plugin );	66	QSync::Result result = member.instance();
65		67
66	if ( !result.isError() )	68	if ( !result.isError() )
67	mGroup.save();	69	mGroup.save();
Lines 69-108 Link Here
69	return result;	71	return result;
70	}	72	}
71		73
		74	void SyncProcess::removeMember( const QSync::Member &member )
		75	{
		76	member.cleanup();
		77	mGroup.removeMember( member );
		78	mGroup.save();
		79	}
		80
72	void SyncProcess::reinitEngine()	81	void SyncProcess::reinitEngine()
73	{	82	{
74	mEngine->finalize();	83	mEngine->finalize();
75	delete mEngine;	84	delete mEngine;
76	mEngine = new QSync::Engine( mGroup );	85	mEngine = new QSync::Engine( mGroup );
77	Result result = mEngine->initialize();	86	Result result = mEngine->initialize();
78	if ( result.isError() )	87	if ( result.isError() ) {
79	kdDebug() << "SyncProcess::reinitEngine: " << result.message() << endl;	88	kdDebug() << "SyncProcess::reinitEngine: " << result.message() << endl;
		89	KMessageBox::error( 0, i18n("Error initializing Synchronization Engine for group \"%1\":\n %2")
		90	.arg( mGroup.name() ).arg( result.message() ) );
80		91
81	applyObjectTypeFilter();	92	}
82		93
83	emit engineChanged( mEngine );	94	emit engineChanged( mEngine );
84	}	95	}
85		96
86	void SyncProcess::applyObjectTypeFilter()
87	{
88	const QSync::Conversion conversion = SyncProcessManager::self()->environment()->conversion();
89	const QStringList objectTypes = conversion.objectTypes();
90	const QStringList activeObjectTypes = mGroup.config().activeObjectTypes();
91
92	for ( uint i = 0; i < objectTypes.count(); ++i ) {
93	if ( activeObjectTypes.contains( objectTypes[ i ] ) ) {
94	kdDebug() << "Enabled object type: " << objectTypes[ i ] << endl;
95	/*
96	* This is not required. Also this lead to filtering problems when sync with "file-sync".
97	* Uncomment this line again when OpenSync is fixed!
98	*
99	* mGroup.setObjectTypeEnabled( objectTypes[ i ], true );
100	*/
101	} else {
102	kdDebug() << "Disabled object type: " << objectTypes[ i ] << endl;
103	mGroup.setObjectTypeEnabled( objectTypes[ i ], false );
104	}
105	}
106	}
107
108	#include "syncprocess.moc"	97	#include "syncprocess.moc"

Lines 44-55 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/syncprocess.h (-3 / +1 lines)
44	QString memberStatus( const QSync::Member &member ) const;	44	QString memberStatus( const QSync::Member &member ) const;
45		45
46	QSync::Result addMember( const QSync::Plugin &plugin );	46	QSync::Result addMember( const QSync::Plugin &plugin );
		47	void removeMember( const QSync::Member &member );
47		48
48	void reinitEngine();	49	void reinitEngine();
49		50
50	/ apply object type filter hack /
51	void applyObjectTypeFilter();
52
53	signals:	51	signals:
54	/**	52	/**
55	This signal is emitted whenever the engine has changed ( reinitialized ).	53	This signal is emitted whenever the engine has changed ( reinitialized ).

Line 0 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/xmldiffalgo.cpp (+166 lines)
		1	/*
		2	This file is part of KitchenSync.
		3
		4	Copyright (c) 2006 Daniel Gollub <dgollub@suse.de>
		5
		6	This program is free software; you can redistribute it and/or
		7	modify it under the terms of the GNU Library General Public
		8	License as published by the Free Software Foundation; either
		9	version 2 of the License, or (at your option) any later version.
		10
		11	This library is distributed in the hope that it will be useful,
		12	but WITHOUT ANY WARRANTY; without even the implied warranty of
		13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		14	Library General Public License for more details.
		15
		16	You should have received a copy of the GNU Library General Public License
		17	along with this library; see the file COPYING.LIB. If not, write to
		18	the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
		19	Boston, MA 02110-1301, USA.
		20	*/
		21
		22	#include "xmldiffalgo.h"
		23
		24	#include <kdebug.h>
		25
		26	using namespace KSync;
		27
		28	#ifndef KDE_USE_FINAL
		29	// With --enable-final, we get the (identical) compareString from
		30	// addresseediffalgo.cpp
		31	//
		32	static bool compareString( const QString &left, const QString &right )
		33	{
		34	if ( left.isEmpty() && right.isEmpty() )
		35	return true;
		36	else
		37	return left == right;
		38	}
		39	#endif
		40
		41	XmlDiffAlgo::XmlDiffAlgo( const QString &leftXml, const QString &rightXml )
		42	{
		43	kdDebug() << __func__ << " " << __LINE__ << endl;
		44
		45	mLeftXml.setContent( leftXml );
		46	mRightXml.setContent( rightXml );
		47
		48	}
		49
		50	XmlDiffAlgo::XmlDiffAlgo( const QDomDocument &leftXml, const QDomDocument &rightXml )
		51	: mLeftXml( leftXml ), mRightXml( rightXml )
		52	{
		53	kdDebug() << __func__ << " " << __LINE__ << endl;
		54	}
		55
		56	void XmlDiffAlgo::appendSingleNodes(QDomElement &element, bool isLeft)
		57	{
		58	QDomNode node;
		59
		60	for ( node = element.firstChild(); !node.isNull(); node = node.nextSibling() ) {
		61	QDomElement child = node.toElement();
		62
		63	if (isLeft)
		64	additionalLeftField( node.nodeName(), child.text() );
65	else
66	additionalRightField( node.nodeName(), child.text() );
67	}
68
69	}
70
71	void XmlDiffAlgo::appendConflictNodes(QDomElement &leftElement, QDomElement &rightElement)
72	{
73	QDomNode left, right;
74	QDomElement leftChild, rightChild;
75
76	for ( left = leftElement.firstChild(); !left.isNull(); left = left.nextSibling() ) {
77	leftChild = left.toElement();
78
79	for ( right = rightElement.firstChild(); !right.isNull(); right = right.nextSibling() ) {
80	rightChild = right.toElement();
81
82	if ( leftChild.tagName() != rightChild.tagName() )
83	continue;
84
85	if (leftChild.text().isEmpty() \|\| rightChild.text().isEmpty())
86	continue;
87
88	QString id = leftChild.tagName();
89	if (id == "Content")
90	id = left.parentNode().nodeName();
91
92	conflictField( id, leftChild.text(), rightChild.text() );
93
94	left.parentNode().removeChild( left );
95	left = leftElement.firstChild();
96
97	right.parentNode().removeChild( right );
98	right = rightElement.firstChild();
99
100	}
101	}
102	}
103
104	void XmlDiffAlgo::compareNode(QDomElement &leftElement, QDomElement &rightElement)
105	{
106	QDomNode left, right;
107	QDomElement leftChild, rightChild;
108	QDomNodeList nlist;
109	top:;
110
111	for ( left = leftElement.firstChild(); !left.isNull(); left = left.nextSibling() ) {
112	leftChild = left.toElement();
113
114	for ( right = rightElement.firstChild(); !right.isNull(); right = right.nextSibling() ) {
115	rightChild = right.toElement();
116
117	if (leftChild.tagName() != rightChild.tagName())
118	continue;
119
120	if ( left.childNodes().count() > 1 && right.childNodes().count() > 1 ) {
121	compareNode( leftChild, rightChild );
122
123	if ( !left.hasChildNodes() && !right.hasChildNodes() ) {
124	left.parentNode().removeChild( left );
125	right.parentNode().removeChild( right );
126	goto top;
127	}
128
129	break;
130	}
131
132	if ( leftChild.text() == rightChild.text() ) {
133	QString id = leftChild.tagName();
134
135	if ( id == "Content" )
136	id = left.parentNode().nodeName();
137
138	if ( id != "Type" )
139	//matchingField( id, leftChild.text(), rightChild.text() );
140
141	left.parentNode().removeChild( left );
142	right.parentNode().removeChild( right );
143	goto top;
144	}
145	}
146	}
147
148	appendConflictNodes(rightElement, leftElement);
149
150	appendSingleNodes(rightElement, false);
151	appendSingleNodes(leftElement, true);
152	}
153
154	void XmlDiffAlgo::run()
155	{
156	kdDebug() << __func__ << endl;
157	begin();
158
159	QDomElement leftElement = mLeftXml.documentElement();
160	QDomElement rightElement = mRightXml.documentElement();
161
162	compareNode( leftElement, rightElement );
163
164	end();
165	}
166

Line 0 Link Here

(-)work/kitchensync-3.5.8/kitchensync.old/src/xmldiffalgo.h (+54 lines)
	1	/*
	2	This file is part of KitchenSync
	3
	4	Copyright (c) 2006 Daniel Gollub <dgollub@suse.de>
	5
	6	This program is free software; you can redistribute it and/or
	7	modify it under the terms of the GNU Library General Public
	8	License as published by the Free Software Foundation; either
	9	version 2 of the License, or (at your option) any later version.
	10
	11	This library is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	Library General Public License for more details.
	15
	16	You should have received a copy of the GNU Library General Public License
	17	along with this library; see the file COPYING.LIB. If not, write to
	18	the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	19	Boston, MA 02110-1301, USA.
	20	*/
	21
	22	#ifndef KSYNC_XMLDIFFALGO_H
	23	#define KSYNC_XMLDIFFALGO_H
	24
	25	#include <qdom.h>
	26
	27	#include <libkdepim/diffalgo.h>
	28
	29	using namespace KPIM;
	30
	31	namespace KSync {
	32
	33	class XmlDiffAlgo : public DiffAlgo
	34	{
	35	public:
	36	XmlDiffAlgo( const QString &leftXml, const QString &rightXml );
	37	XmlDiffAlgo( const QDomDocument &leftXml, const QDomDocument &rightXml );
	38
	39	void run();
	40
	41	private:
	42	void appendConflictNodes(QDomElement &leftElement, QDomElement &rightElement);
	43	void appendSingleNodes(QDomElement &element, bool isLeft);
	44
	45
	46	void compareNode(QDomElement &leftElement, QDomElement &rightElement);
	47
	48	QDomDocument mLeftXml;
	49	QDomDocument mRightXml;
	50	};
	51
	52	}
	53
	54	#endif