← Back to branch summary

~ubuntu-branches/debian/squeeze/inkscape/squeeze

« back to all changes in this revision

Viewing changes to src/jabber_whiteboard/message-processors.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Thomas Viehmann
  • Date: 2008-09-09 23:29:02 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20080909232902-c50iujhk1w79u8e7
Tags: 0.46-2.1
http://bugs.debian.org/487623
* Non-maintainer upload.
* Add upstream patch fixing a crash in the open dialog
  in the zh_CN.utf8 locale. Closes: #487623.
  Thanks to Luca Bruno for the patch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/jabber_whiteboard/message-processors.cpp
1
 
/**
2
 
 * Whiteboard session manager
3
 
 * Jabber received message processors
4
 
 *
5
 
 * Authors:
6
 
 * David Yip <yipdw@rose-hulman.edu>
7
 
 *
8
 
 * Copyright (c) 2005 Authors
9
 
 *
10
 
 * Released under GNU GPL, read the file 'COPYING' for more information
11
 
 */
12
 
 
13
 
extern "C" {
14
 
#include <loudmouth/loudmouth.h>
15
 
}
16
 
 
17
 
#include <glibmm/i18n.h>
18
 
 
19
 
#include "xml/session.h"
20
 
#include "xml/document.h"
21
 
 
22
 
#include "desktop-handles.h"
23
 
#include "document.h"
24
 
#include "message-stack.h"
25
 
 
26
 
#include "jabber_whiteboard/undo-stack-observer.h"
27
 
#include "jabber_whiteboard/session-manager.h"
28
 
#include "jabber_whiteboard/message-node.h"
29
 
#include "jabber_whiteboard/message-queue.h"
30
 
#include "jabber_whiteboard/message-processors.h"
31
 
#include "jabber_whiteboard/typedefs.h"
32
 
 
33
 
namespace Inkscape {
34
 
 
35
 
namespace Whiteboard {
36
 
 
37
 
// Message processors are here!
38
 
 
39
 
// TODO: Remove unnecessary status checks from processors --
40
 
// we do all of that in MessageHandler::_hasValidReceiveContext
41
 
 
42
 
// *********************************************************************
43
 
// ChangeHandler begin
44
 
// *********************************************************************
45
 
 
46
 
/**
47
 
 * MessageProcessor for document change and event commit messages.
48
 
 */
49
 
struct ChangeHandler : public MessageProcessor {
50
 
public:
51
 
        ~ChangeHandler()
52
 
        {
53
 
 
54
 
        }
55
 
 
56
 
        ChangeHandler(SessionManager* sm) : MessageProcessor(sm)
57
 
        {
58
 
 
59
 
        }
60
 
 
61
 
        LmHandlerResult
62
 
        operator()(MessageType mode, JabberMessage& p)
63
 
        {
64
 
                MessageNode* msgNode;
65
 
                bool chatroom = this->_sm->session_data->status[IN_CHATROOM];
66
 
 
67
 
                ReceiveMessageQueue* rmq = this->_sm->session_data->receive_queues[p.sender];
68
 
 
69
 
                if (rmq != NULL) {
70
 
                        switch (mode) {
71
 
                                case CHANGE_REPEATABLE:
72
 
                                case CHANGE_NOT_REPEATABLE:
73
 
                                case DOCUMENT_BEGIN:
74
 
                                        msgNode = new MessageNode(p.sequence, p.sender, "", p.body, mode, false, chatroom);
75
 
                                        rmq->insert(msgNode);
76
 
                                        Inkscape::GC::release(msgNode);
77
 
                                        break;
78
 
                                case DOCUMENT_END:
79
 
                                        this->_sm->session_data->recipients_committed_queue.push_back(p.sender);
80
 
                                        msgNode = new MessageNode(p.sequence, p.sender, "", p.body, mode, false, chatroom);
81
 
                                        rmq->insert(msgNode);
82
 
                                        Inkscape::GC::release(msgNode);
83
 
                                        break;
84
 
                                case CHANGE_COMMIT:
85
 
                                        this->_sm->session_data->recipients_committed_queue.push_back(p.sender);
86
 
                                        msgNode = new MessageNode(p.sequence, p.sender, "", p.body, CHANGE_COMMIT, false, chatroom);
87
 
                                        rmq->insert(msgNode);
88
 
                                        Inkscape::GC::release(msgNode);
89
 
                                        break;
90
 
                                case DUMMY_CHANGE:
91
 
                                default:
92
 
                                        break;
93
 
                        }
94
 
                } else {
95
 
                        g_warning("Received message from unknown sender %s", p.sender.c_str());
96
 
                }
97
 
                
98
 
                return LM_HANDLER_RESULT_REMOVE_MESSAGE;
99
 
        }
100
 
};
101
 
// *********************************************************************
102
 
// ChangeHandler end
103
 
// *********************************************************************
104
 
 
105
 
 
106
 
// *********************************************************************
107
 
// ConnectRequestHandler begin
108
 
// *********************************************************************
109
 
/**
110
 
 * MessageProcessor for connection request messages.
111
 
 */
112
 
struct ConnectRequestHandler : public MessageProcessor {
113
 
public:
114
 
        ~ConnectRequestHandler()
115
 
        {
116
 
 
117
 
        }
118
 
 
119
 
        ConnectRequestHandler(SessionManager* sm) : MessageProcessor(sm) 
120
 
        {
121
 
 
122
 
        }
123
 
 
124
 
        LmHandlerResult 
125
 
        operator()(MessageType mode, JabberMessage& m)
126
 
        {
127
 
                std::bitset< NUM_FLAGS >& status = this->_sm->session_data->status;
128
 
                switch(mode) {
129
 
                        case CONNECT_REQUEST_USER:
130
 
                                this->_sm->receiveConnectRequest(m.sender.c_str());
131
 
                                break;
132
 
                        case CONNECT_REQUEST_RESPONSE_USER:
133
 
                                if (m.sequence == 0) {
134
 
                                        this->_sm->receiveConnectRequestResponse(DECLINE_INVITATION, m.sender);
135
 
                                } else { // FIXME: this has got to be buggy...
136
 
                                        this->_sm->setRecipient(m.sender.c_str());
137
 
                                        this->_sm->receiveConnectRequestResponse(ACCEPT_INVITATION, m.sender);
138
 
                                }
139
 
                                break;
140
 
                        case Inkscape::Whiteboard::CONNECTED_SIGNAL:
141
 
                                if (!status[IN_CHATROOM] && !status[CONNECTING_TO_CHAT] && !status[SYNCHRONIZING_WITH_CHAT] && !status[WAITING_TO_SYNC_TO_CHAT]) {
142
 
                                        this->_sm->userConnectedToWhiteboard(m.sender.c_str());
143
 
                                        this->_sm->setRecipient(m.sender.c_str());
144
 
                                } else {
145
 
                                        sp_desktop_message_stack(this->_sm->desktop())->flashF(Inkscape::INFORMATION_MESSAGE, _("<b>%s</b> has joined the chatroom."), m.sender.c_str());
146
 
                                }
147
 
                                break;
148
 
                        default:
149
 
                                break;
150
 
                }
151
 
                return LM_HANDLER_RESULT_REMOVE_MESSAGE;
152
 
        }
153
 
};
154
 
// *********************************************************************
155
 
// ConnectRequestHandler end
156
 
// *********************************************************************
157
 
 
158
 
 
159
 
 
160
 
 
161
 
// *********************************************************************
162
 
// ConnectErrorHandler begin
163
 
// *********************************************************************
164
 
/**
165
 
 * MessageProcessor for connection error messages.  
166
 
 */
167
 
struct ConnectErrorHandler : public MessageProcessor {
168
 
public:
169
 
        ~ConnectErrorHandler()
170
 
        {
171
 
 
172
 
        }
173
 
 
174
 
        ConnectErrorHandler(SessionManager* sm) : MessageProcessor(sm) 
175
 
        {
176
 
 
177
 
        }
178
 
 
179
 
        LmHandlerResult 
180
 
        operator()(MessageType mode, JabberMessage& m)
181
 
        {
182
 
                switch(mode) {
183
 
                        case CONNECT_REQUEST_REFUSED_BY_PEER:
184
 
                                if (this->_sm->session_data->status[WAITING_FOR_INVITE_RESPONSE]) {
185
 
                                        this->_sm->receiveConnectRequestResponse(DECLINE_INVITATION, m.sender);
186
 
                                }
187
 
                                break;
188
 
                        case Inkscape::Whiteboard::ALREADY_IN_SESSION:
189
 
                                if (this->_sm->session_data->status[WAITING_FOR_INVITE_RESPONSE]) {
190
 
                                        this->_sm->receiveConnectRequestResponse(PEER_ALREADY_IN_SESSION, m.sender);
191
 
                                }
192
 
                                break;
193
 
                        case Inkscape::Whiteboard::DISCONNECTED_FROM_USER_SIGNAL:
194
 
                                if (!this->_sm->session_data->status[IN_CHATROOM]) {
195
 
                                        this->_sm->closeSession();
196
 
                                        this->_sm->userDisconnectedFromWhiteboard(m.sender.c_str());
197
 
                                }
198
 
                                break;
199
 
                        default:
200
 
                                break;
201
 
                }
202
 
                return LM_HANDLER_RESULT_REMOVE_MESSAGE;
203
 
        }
204
 
};
205
 
// *********************************************************************
206
 
// ConnectErrorHandler end
207
 
// *********************************************************************
208
 
 
209
 
 
210
 
 
211
 
 
212
 
// *********************************************************************
213
 
// ChatSynchronizeHandler begin
214
 
// *********************************************************************
215
 
/**
216
 
 * MessageProcessor for messages specific to chatroom synchronization.
217
 
 */
218
 
struct ChatSynchronizeHandler : public MessageProcessor {
219
 
public:
220
 
        ~ChatSynchronizeHandler()
221
 
        {
222
 
 
223
 
        }
224
 
 
225
 
        ChatSynchronizeHandler(SessionManager* sm) : MessageProcessor(sm) 
226
 
        {
227
 
 
228
 
        }
229
 
 
230
 
        LmHandlerResult 
231
 
        operator()(MessageType mode, JabberMessage& m)
232
 
        {
233
 
                switch(mode) {
234
 
                        case CONNECT_REQUEST_RESPONSE_CHAT:
235
 
                                this->_sm->receiveConnectRequestResponseChat(m.sender.c_str());
236
 
                                break;
237
 
                        case CHATROOM_SYNCHRONIZE_REQUEST:
238
 
                                if (this->_sm->session_data->status[IN_CHATROOM] && this->_sm->session_data->status[IN_WHITEBOARD]) {
239
 
                                        // Send response.  Everyone in the chatroom will do this,
240
 
                                        // but the client will accept only one response.
241
 
                                        // The response is sent privately to the client
242
 
                                        // <http://www.jabber.org/jeps/jep-0045.html#privatemessage>
243
 
                                        this->_sm->sendMessage(CHATROOM_SYNCHRONIZE_RESPONSE, this->_sm->session_data->sequence_number, "", m.sender.c_str(), false);
244
 
                                }
245
 
                                break;
246
 
                        case CHATROOM_SYNCHRONIZE_RESPONSE:
247
 
                                if (m.sequence != 0) {
248
 
                                        // Set sequence number
249
 
                                        this->_sm->session_data->sequence_number = m.sequence;
250
 
 
251
 
                                        // Set status flags
252
 
                                        this->_sm->session_data->status.set(WAITING_TO_SYNC_TO_CHAT, 0);
253
 
                                        this->_sm->session_data->status.set(SYNCHRONIZING_WITH_CHAT, 1);
254
 
 
255
 
                                        // Send document synchronization request
256
 
                                        this->_sm->clearDocument();
257
 
                                        this->_sm->setupInkscapeInterface();
258
 
                                        this->_sm->sendMessage(CONNECT_REQUEST_RESPONSE_CHAT, m.sequence, "", m.sender.c_str(), false);
259
 
                                } else {
260
 
                                        this->_sm->sendMessage(CHATROOM_SYNCHRONIZE_REQUEST, 0, "", this->_sm->session_data->recipient, true);
261
 
                                }
262
 
                                break;
263
 
                        default:
264
 
                                break;
265
 
                }
266
 
                return LM_HANDLER_RESULT_REMOVE_MESSAGE;
267
 
        }
268
 
};
269
 
// *********************************************************************
270
 
// ChatSynchronizeHandler end
271
 
// *********************************************************************
272
 
 
273
 
 
274
 
 
275
 
 
276
 
// *********************************************************************
277
 
// Initializer
278
 
// *********************************************************************
279
 
void
280
 
initialize_received_message_processors(SessionManager* sm, MessageProcessorMap& mpm)
281
 
{
282
 
        MessageProcessor* ch = new ChangeHandler(sm);
283
 
        MessageProcessor* crh = new ConnectRequestHandler(sm);
284
 
        MessageProcessor* ceh = new ConnectErrorHandler(sm);
285
 
        MessageProcessor* csh = new ChatSynchronizeHandler(sm);
286
 
 
287
 
        mpm[CHANGE_REPEATABLE] = ch;
288
 
        mpm[CHANGE_NOT_REPEATABLE] = ch;
289
 
        mpm[DUMMY_CHANGE] = ch;
290
 
        mpm[CHANGE_COMMIT] = ch;
291
 
        mpm[DOCUMENT_BEGIN] = ch;
292
 
        mpm[DOCUMENT_END] = ch;
293
 
 
294
 
        mpm[CONNECT_REQUEST_USER] = crh;
295
 
        mpm[CONNECT_REQUEST_RESPONSE_USER] = crh;
296
 
        mpm[CONNECTED_SIGNAL] = crh;
297
 
 
298
 
        mpm[CONNECT_REQUEST_REFUSED_BY_PEER] = ceh;
299
 
        mpm[ALREADY_IN_SESSION] = ceh;
300
 
        mpm[DISCONNECTED_FROM_USER_SIGNAL] = ceh;
301
 
 
302
 
        mpm[CONNECT_REQUEST_RESPONSE_CHAT] = csh;
303
 
        mpm[CHATROOM_SYNCHRONIZE_REQUEST] = csh;
304
 
        mpm[CHATROOM_SYNCHRONIZE_RESPONSE] = csh;
305
 
}
306
 
 
307
 
/*
308
 
 * This function is provided solely for convenience and style.  You can, of course,
309
 
 * delete every MessageProcessor in the map with your own loop.
310
 
 */
311
 
void
312
 
destroy_received_message_processors(MessageProcessorMap& mpm)
313
 
{
314
 
        mpm.clear();
315
 
}
316
 
 
317
 
}
318
 
 
319
 
}
320
 
 
321
 
/*
322
 
  Local Variables:
323
 
  mode:c++
324
 
  c-file-style:"stroustrup"
325
 
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
326
 
  indent-tabs-mode:nil
327
 
  fill-column:99
328
 
  End:
329
 
*/
330
 
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :