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
30using namespace QSync;
31
32class 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
46class 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
60class 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
74class 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
88class 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
102CallbackHandler::CallbackHandler()
103{
104}
105
106CallbackHandler::~CallbackHandler()
107{
108}
109
110void 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
121Engine* CallbackHandler::engine() const
122{
123 return mEngine;
124}
125
126void 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
146void 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
155void 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
164void 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
173void 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
182void 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"