kitchensync
callbackhandler.cpp00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <osengine/engine.h>
00023
00024 #include <libqopensync/engine.h>
00025
00026 #include <tqapplication.h>
00027
00028 #include "callbackhandler.h"
00029
00030 using namespace QSync;
00031
00032 class CallbackHandler::ConflictEvent : public TQCustomEvent
00033 {
00034 public:
00035 ConflictEvent( const SyncMapping& mapping )
00036 : TQCustomEvent( 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 TQCustomEvent
00047 {
00048 public:
00049 ChangeEvent( const SyncChangeUpdate& change )
00050 : TQCustomEvent( 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 TQCustomEvent
00061 {
00062 public:
00063 MappingEvent( const SyncMappingUpdate& mapping )
00064 : TQCustomEvent( 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 TQCustomEvent
00075 {
00076 public:
00077 EngineEvent( const SyncEngineUpdate& engine )
00078 : TQCustomEvent( 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 TQCustomEvent
00089 {
00090 public:
00091 MemberEvent( const SyncMemberUpdate& member )
00092 : TQCustomEvent( 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( TQCustomEvent *event )
00127 {
00128 if ( event->type() == static_cast<TQEvent::Type>( ConflictEventType ) ) {
00129 ConflictEvent *conflictEvent = static_cast<ConflictEvent*>( event );
00130 emit conflict( conflictEvent->mapping() );
00131 } else if ( event->type() == static_cast<TQEvent::Type>( ChangeEventType ) ) {
00132 ChangeEvent *changeEvent = static_cast<ChangeEvent*>( event );
00133 emit change( changeEvent->change() );
00134 } else if ( event->type() == static_cast<TQEvent::Type>( MappingEventType ) ) {
00135 MappingEvent *mappingEvent = static_cast<MappingEvent*>( event );
00136 emit mapping( mappingEvent->mapping() );
00137 } else if ( event->type() == static_cast<TQEvent::Type>( EngineEventType ) ) {
00138 EngineEvent *engineEvent = static_cast<EngineEvent*>( event );
00139 emit engine( engineEvent->engine() );
00140 } else if ( event->type() == static_cast<TQEvent::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 TQApplication::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 TQApplication::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 TQApplication::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 TQApplication::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 TQApplication::postEvent( handler, new MemberEvent( member ) );
00189 }
00190
00191 #include "callbackhandler.moc"
|