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