callbackhandler.cpp
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 <osengine/engine.h>
23 
24 #include <libqopensync/engine.h>
25 
26 #include <tqapplication.h>
27 
28 #include "callbackhandler.h"
29 
30 using namespace QSync;
31 
32 class CallbackHandler::ConflictEvent : public TQCustomEvent
33 {
34  public:
35  ConflictEvent( const SyncMapping& mapping )
36  : TQCustomEvent( ConflictEventType ), mMapping( mapping )
37  {
38  }
39 
40  SyncMapping mapping() const { return mMapping; }
41 
42  private:
43  SyncMapping mMapping;
44 };
45 
46 class CallbackHandler::ChangeEvent : public TQCustomEvent
47 {
48  public:
49  ChangeEvent( const SyncChangeUpdate& change )
50  : TQCustomEvent( ChangeEventType ), mChange( change )
51  {
52  }
53 
54  SyncChangeUpdate change() const { return mChange; }
55 
56  private:
57  SyncChangeUpdate mChange;
58 };
59 
60 class CallbackHandler::MappingEvent : public TQCustomEvent
61 {
62  public:
63  MappingEvent( const SyncMappingUpdate& mapping )
64  : TQCustomEvent( MappingEventType ), mMapping( mapping )
65  {
66  }
67 
68  SyncMappingUpdate mapping() const { return mMapping; }
69 
70  private:
71  SyncMappingUpdate mMapping;
72 };
73 
74 class CallbackHandler::EngineEvent : public TQCustomEvent
75 {
76  public:
77  EngineEvent( const SyncEngineUpdate& engine )
78  : TQCustomEvent( EngineEventType ), mEngine( engine )
79  {
80  }
81 
82  SyncEngineUpdate engine() const { return mEngine; }
83 
84  private:
85  SyncEngineUpdate mEngine;
86 };
87 
88 class CallbackHandler::MemberEvent : public TQCustomEvent
89 {
90  public:
91  MemberEvent( const SyncMemberUpdate& member )
92  : TQCustomEvent( MemberEventType ), mMember( member )
93  {
94  }
95 
96  SyncMemberUpdate member() const { return mMember; }
97 
98  private:
99  SyncMemberUpdate mMember;
100 };
101 
102 CallbackHandler::CallbackHandler()
103 {
104 }
105 
106 CallbackHandler::~CallbackHandler()
107 {
108 }
109 
110 void CallbackHandler::setEngine( Engine *engine )
111 {
112  mEngine = engine;
113 
114  osengine_set_conflict_callback( engine->mEngine, &conflict_callback, this );
115  osengine_set_changestatus_callback( engine->mEngine, &change_callback, this );
116  osengine_set_mappingstatus_callback( engine->mEngine, &mapping_callback, this );
117  osengine_set_enginestatus_callback( engine->mEngine, &engine_callback, this );
118  osengine_set_memberstatus_callback( engine->mEngine, &member_callback, this );
119 }
120 
121 Engine* CallbackHandler::engine() const
122 {
123  return mEngine;
124 }
125 
126 void CallbackHandler::customEvent( TQCustomEvent *event )
127 {
128  if ( event->type() == static_cast<TQEvent::Type>( ConflictEventType ) ) {
129  ConflictEvent *conflictEvent = static_cast<ConflictEvent*>( event );
130  emit conflict( conflictEvent->mapping() );
131  } else if ( event->type() == static_cast<TQEvent::Type>( ChangeEventType ) ) {
132  ChangeEvent *changeEvent = static_cast<ChangeEvent*>( event );
133  emit change( changeEvent->change() );
134  } else if ( event->type() == static_cast<TQEvent::Type>( MappingEventType ) ) {
135  MappingEvent *mappingEvent = static_cast<MappingEvent*>( event );
136  emit mapping( mappingEvent->mapping() );
137  } else if ( event->type() == static_cast<TQEvent::Type>( EngineEventType ) ) {
138  EngineEvent *engineEvent = static_cast<EngineEvent*>( event );
139  emit engine( engineEvent->engine() );
140  } else if ( event->type() == static_cast<TQEvent::Type>( MemberEventType ) ) {
141  MemberEvent *memberEvent = static_cast<MemberEvent*>( event );
142  emit member( memberEvent->member() );
143  }
144 }
145 
146 void CallbackHandler::conflict_callback( OSyncEngine *engine, OSyncMapping *omapping, void *data )
147 {
148  SyncMapping mapping( omapping, engine );
149 
150  CallbackHandler *handler = static_cast<CallbackHandler*>( data );
151 
152  TQApplication::postEvent( handler, new ConflictEvent( mapping ) );
153 }
154 
155 void CallbackHandler::change_callback( OSyncEngine*, OSyncChangeUpdate *update, void *data )
156 {
157  SyncChangeUpdate change( update );
158 
159  CallbackHandler *handler = static_cast<CallbackHandler*>( data );
160 
161  TQApplication::postEvent( handler, new ChangeEvent( change ) );
162 }
163 
164 void CallbackHandler::mapping_callback( OSyncMappingUpdate *update, void *data )
165 {
166  CallbackHandler *handler = static_cast<CallbackHandler*>( data );
167 
168  SyncMappingUpdate mapping( update, handler->engine()->mEngine );
169 
170  TQApplication::postEvent( handler, new MappingEvent( mapping ) );
171 }
172 
173 void CallbackHandler::engine_callback( OSyncEngine*, OSyncEngineUpdate *update, void *data )
174 {
175  SyncEngineUpdate engine( update );
176 
177  CallbackHandler *handler = static_cast<CallbackHandler*>( data );
178 
179  TQApplication::postEvent( handler, new EngineEvent( engine ) );
180 }
181 
182 void CallbackHandler::member_callback( OSyncMemberUpdate *update, void *data )
183 {
184  SyncMemberUpdate member( update );
185 
186  CallbackHandler *handler = static_cast<CallbackHandler*>( data );
187 
188  TQApplication::postEvent( handler, new MemberEvent( member ) );
189 }
190 
191 #include "callbackhandler.moc"