kitchensync

callbackhandler.cpp

00001 /*
00002     This file is part of libqopensync.
00003 
00004     Copyright (c) 2005 Tobias Koenig <tokoe@kde.org>
00005 
00006     This library is free software; you can redistribute it and/or
00007     modify it under the terms of the GNU Library General Public
00008     License as published by the Free Software Foundation; either
00009     version 2 of the License, or (at your option) any later version.
00010 
00011     This library is distributed in the hope that it will be useful,
00012     but WITHOUT ANY WARRANTY; without even the implied warranty of
00013     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014     Library General Public License for more details.
00015 
00016     You should have received a copy of the GNU Library General Public License
00017     along with this library; see the file COPYING.LIB.  If not, write to
00018     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00019     Boston, MA 02110-1301, USA.
00020 */
00021 
00022 #include <osengine/engine.h>
00023 
00024 #include <libqopensync/engine.h>
00025 
00026 #include <qapplication.h>
00027 
00028 #include "callbackhandler.h"
00029 
00030 using namespace QSync;
00031 
00032 class CallbackHandler::ConflictEvent : public QCustomEvent
00033 {
00034   public:
00035     ConflictEvent( const SyncMapping& mapping )
00036       : QCustomEvent( ConflictEventType ), mMapping( mapping )
00037     {
00038     }
00039 
00040     SyncMapping mapping() const { return mMapping; }
00041 
00042   private:
00043     SyncMapping mMapping;
00044 };
00045 
00046 class CallbackHandler::ChangeEvent : public QCustomEvent
00047 {
00048   public:
00049     ChangeEvent( const SyncChangeUpdate& change )
00050       : QCustomEvent( ChangeEventType ), mChange( change )
00051     {
00052     }
00053 
00054     SyncChangeUpdate change() const { return mChange; }
00055 
00056   private:
00057     SyncChangeUpdate mChange;
00058 };
00059 
00060 class CallbackHandler::MappingEvent : public QCustomEvent
00061 {
00062   public:
00063     MappingEvent( const SyncMappingUpdate& mapping )
00064       : QCustomEvent( MappingEventType ), mMapping( mapping )
00065     {
00066     }
00067 
00068     SyncMappingUpdate mapping() const { return mMapping; }
00069 
00070   private:
00071     SyncMappingUpdate mMapping;
00072 };
00073 
00074 class CallbackHandler::EngineEvent : public QCustomEvent
00075 {
00076   public:
00077     EngineEvent( const SyncEngineUpdate& engine )
00078       : QCustomEvent( EngineEventType ), mEngine( engine )
00079     {
00080     }
00081 
00082     SyncEngineUpdate engine() const { return mEngine; }
00083 
00084   private:
00085     SyncEngineUpdate mEngine;
00086 };
00087 
00088 class CallbackHandler::MemberEvent : public QCustomEvent
00089 {
00090   public:
00091     MemberEvent( const SyncMemberUpdate& member )
00092       : QCustomEvent( MemberEventType ), mMember( member )
00093     {
00094     }
00095 
00096     SyncMemberUpdate member() const { return mMember; }
00097 
00098   private:
00099     SyncMemberUpdate mMember;
00100 };
00101 
00102 CallbackHandler::CallbackHandler()
00103 {
00104 }
00105 
00106 CallbackHandler::~CallbackHandler()
00107 {
00108 }
00109 
00110 void CallbackHandler::setEngine( Engine *engine )
00111 {
00112   mEngine = engine;
00113 
00114   osengine_set_conflict_callback( engine->mEngine, &conflict_callback, this );
00115   osengine_set_changestatus_callback( engine->mEngine, &change_callback, this );
00116   osengine_set_mappingstatus_callback( engine->mEngine, &mapping_callback, this );
00117   osengine_set_enginestatus_callback( engine->mEngine, &engine_callback, this );
00118   osengine_set_memberstatus_callback( engine->mEngine, &member_callback, this );
00119 }
00120 
00121 Engine* CallbackHandler::engine() const
00122 {
00123   return mEngine;
00124 }
00125 
00126 void CallbackHandler::customEvent( QCustomEvent *event )
00127 {
00128   if ( event->type() == static_cast<QEvent::Type>( ConflictEventType ) ) {
00129     ConflictEvent *conflictEvent = static_cast<ConflictEvent*>( event );
00130     emit conflict( conflictEvent->mapping() );
00131   } else if ( event->type() == static_cast<QEvent::Type>( ChangeEventType ) ) {
00132     ChangeEvent *changeEvent = static_cast<ChangeEvent*>( event );
00133     emit change( changeEvent->change() );
00134   } else if ( event->type() == static_cast<QEvent::Type>( MappingEventType ) ) {
00135     MappingEvent *mappingEvent = static_cast<MappingEvent*>( event );
00136     emit mapping( mappingEvent->mapping() );
00137   } else if ( event->type() == static_cast<QEvent::Type>( EngineEventType ) ) {
00138     EngineEvent *engineEvent = static_cast<EngineEvent*>( event );
00139     emit engine( engineEvent->engine() );
00140   } else if ( event->type() == static_cast<QEvent::Type>( MemberEventType ) ) {
00141     MemberEvent *memberEvent = static_cast<MemberEvent*>( event );
00142     emit member( memberEvent->member() );
00143   }
00144 }
00145 
00146 void CallbackHandler::conflict_callback( OSyncEngine *engine, OSyncMapping *omapping, void *data )
00147 {
00148   SyncMapping mapping( omapping, engine );
00149 
00150   CallbackHandler *handler = static_cast<CallbackHandler*>( data );
00151 
00152   QApplication::postEvent( handler, new ConflictEvent( mapping ) );
00153 }
00154 
00155 void CallbackHandler::change_callback( OSyncEngine*, OSyncChangeUpdate *update, void *data )
00156 {
00157   SyncChangeUpdate change( update );
00158 
00159   CallbackHandler *handler = static_cast<CallbackHandler*>( data );
00160 
00161   QApplication::postEvent( handler, new ChangeEvent( change ) );
00162 }
00163 
00164 void CallbackHandler::mapping_callback( OSyncMappingUpdate *update, void *data )
00165 {
00166   CallbackHandler *handler = static_cast<CallbackHandler*>( data );
00167 
00168   SyncMappingUpdate mapping( update, handler->engine()->mEngine );
00169 
00170   QApplication::postEvent( handler, new MappingEvent( mapping ) );
00171 }
00172 
00173 void CallbackHandler::engine_callback( OSyncEngine*, OSyncEngineUpdate *update, void *data )
00174 {
00175   SyncEngineUpdate engine( update );
00176 
00177   CallbackHandler *handler = static_cast<CallbackHandler*>( data );
00178 
00179   QApplication::postEvent( handler, new EngineEvent( engine ) );
00180 }
00181 
00182 void CallbackHandler::member_callback( OSyncMemberUpdate *update, void *data )
00183 {
00184   SyncMemberUpdate member( update );
00185 
00186   CallbackHandler *handler = static_cast<CallbackHandler*>( data );
00187 
00188   QApplication::postEvent( handler, new MemberEvent( member ) );
00189 }
00190 
00191 #include "callbackhandler.moc"