← Back to branch summary

~ubuntu-branches/debian/experimental/inkscape/experimental

« back to all changes in this revision

Viewing changes to src/jabber_whiteboard/callbacks.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/callbacks.cpp
1
 
/**
2
 
 * Whiteboard session manager
3
 
 * Message dispatch devices and timeout triggers
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 "message-stack.h"
20
 
#include "document.h"
21
 
#include "desktop-handles.h"
22
 
 
23
 
#include "jabber_whiteboard/undo-stack-observer.h"
24
 
#include "jabber_whiteboard/jabber-handlers.h"
25
 
#include "jabber_whiteboard/defines.h"
26
 
#include "jabber_whiteboard/typedefs.h"
27
 
#include "jabber_whiteboard/session-manager.h"
28
 
#include "jabber_whiteboard/message-queue.h"
29
 
#include "jabber_whiteboard/message-handler.h"
30
 
#include "jabber_whiteboard/message-node.h"
31
 
#include "jabber_whiteboard/callbacks.h"
32
 
 
33
 
namespace Inkscape {
34
 
 
35
 
namespace Whiteboard {
36
 
 
37
 
Callbacks::Callbacks(SessionManager* sm) : _sm(sm) 
38
 
{
39
 
        this->_sd = this->_sm->session_data;
40
 
}
41
 
 
42
 
Callbacks::~Callbacks() 
43
 
{
44
 
}
45
 
 
46
 
bool
47
 
Callbacks::dispatchSendQueue()
48
 
{
49
 
        // If we're not in a whiteboard session, don't dispatch anything
50
 
        if (!(this->_sd->status[IN_WHITEBOARD])) {
51
 
                return false;
52
 
        }
53
 
 
54
 
        // If the connection is not open, inform the user that an error has occurred
55
 
        // and stop the queue
56
 
        LmConnectionState state = lm_connection_get_state(this->_sd->connection);
57
 
 
58
 
        if (state != LM_CONNECTION_STATE_OPEN && state != LM_CONNECTION_STATE_AUTHENTICATED) {
59
 
                sp_desktop_message_stack(this->_sm->desktop())->flash(Inkscape::INFORMATION_MESSAGE, _("Jabber connection lost."));
60
 
                return false;
61
 
        }
62
 
 
63
 
        // If there's nothing to send, don't do anything
64
 
        if (this->_sd->send_queue->empty()) {
65
 
                return true;
66
 
        }
67
 
 
68
 
        // otherwise, send out the first change
69
 
        MessageNode* first = this->_sd->send_queue->first();
70
 
 
71
 
        sp_desktop_message_stack(this->_sm->desktop())->flashF(Inkscape::NORMAL_MESSAGE,
72
 
                                                     ngettext("Sending message; %u message remaining in send queue.",
73
 
                                                              "Sending message; %u messages remaining in send queue.",
74
 
                                                              this->_sd->send_queue->size()),
75
 
                                                     this->_sd->send_queue->size());
76
 
 
77
 
        if (this->_sd->send_queue->empty()) {
78
 
                sp_desktop_message_stack(this->_sm->desktop())->flash(Inkscape::NORMAL_MESSAGE, _("Receive queue empty."));
79
 
        }
80
 
 
81
 
        switch (first->type()) {
82
 
                case CHANGE_REPEATABLE:
83
 
                case CHANGE_NOT_REPEATABLE:
84
 
                case CHANGE_COMMIT:
85
 
                case DOCUMENT_BEGIN:
86
 
                case DOCUMENT_END:
87
 
                        this->_sm->sendMessage(first->type(), first->sequence(), first->message(), first->recipient().c_str(), first->chatroom());
88
 
                        break;
89
 
                default:
90
 
                        g_warning("MessageNode with unknown change type found in send queue; discarding message.  This may lead to desynchronization!");
91
 
                        break;
92
 
        }
93
 
 
94
 
        this->_sd->send_queue->popFront();
95
 
 
96
 
        return true;
97
 
}
98
 
 
99
 
bool
100
 
Callbacks::dispatchReceiveQueue()
101
 
{
102
 
        CommitsQueue& rcq = this->_sd->recipients_committed_queue;
103
 
        // See if we have any commits submitted. 
104
 
        if (!rcq.empty()) {
105
 
                // Pick the first one off the queue.
106
 
                ReceivedCommitEvent& committer = rcq.front();
107
 
 
108
 
                // Find the commit event sender's receive queue.
109
 
                ReceiveMessageQueue* rmq = this->_sd->receive_queues[committer];
110
 
 
111
 
                if (rmq != NULL) {
112
 
                        if (!rmq->empty()) {
113
 
                                // Get the first message off the sender's receive queue.
114
 
                                MessageNode* msg = rmq->first();
115
 
 
116
 
                                // There are a few message change types that demand special processing;
117
 
                                // handle them here.
118
 
                                //
119
 
                                // TODO: clean this up.  This should be a simple dispatching routine,
120
 
                                // and should not be performing operations like it's doing right now.
121
 
                                // These really should go into connection-establishment.cpp
122
 
                                // (although that should only happen after SessionManager itself
123
 
                                // is cleaned up).
124
 
                                switch(msg->type()) {
125
 
                                        case CHANGE_COMMIT:
126
 
                                                rcq.pop_front();
127
 
                                                break;
128
 
                                        case DOCUMENT_BEGIN:
129
 
                                                if (this->_sm->session_data->status[WAITING_TO_SYNC_TO_CHAT]) {
130
 
                                                        this->_sm->session_data->status.set(WAITING_TO_SYNC_TO_CHAT, 0);
131
 
                                                        this->_sm->session_data->status.set(SYNCHRONIZING_WITH_CHAT, 1);
132
 
                                                }
133
 
                                                break;
134
 
                                        case DOCUMENT_END:
135
 
                                                rcq.pop_front();
136
 
                                                if (this->_sm->session_data->status[SYNCHRONIZING_WITH_CHAT]) {
137
 
                                                        this->_sm->sendMessage(CONNECTED_SIGNAL, 0, "", this->_sm->session_data->recipient, true);
138
 
                                                        this->_sm->session_data->status.set(SYNCHRONIZING_WITH_CHAT, 0);
139
 
                                                        this->_sm->session_data->status.set(IN_CHATROOM, 1);
140
 
                                                } else {
141
 
                                                        this->_sm->sendMessage(CONNECTED_SIGNAL, 0, "", msg->sender().c_str(), false);
142
 
                                                }
143
 
                                                break;
144
 
                                        case CHANGE_REPEATABLE:
145
 
                                        case CHANGE_NOT_REPEATABLE:
146
 
                                        default:
147
 
                                                break;
148
 
                                }
149
 
                                
150
 
 
151
 
                                // Pass the message to the received change handler.
152
 
                                this->_sm->receiveChange(msg->message());
153
 
                                sp_desktop_message_stack(this->_sm->desktop())->flashF(Inkscape::NORMAL_MESSAGE,
154
 
                                                                             ngettext("Receiving change; %u change left to process.",
155
 
                                                                                      "Receiving change; %u changes left to process.",
156
 
                                                                                      rmq->size()),
157
 
                                                                             rmq->size());
158
 
 
159
 
                                
160
 
                                // Register this message as the latest message received from this
161
 
                                // sender.
162
 
                                rmq->setLatestProcessedPacket(msg->sequence());
163
 
 
164
 
                                // Pop this message off the receive queue.
165
 
                                rmq->popFront();
166
 
                                return true;
167
 
                        } else {
168
 
                                // This really shouldn't happen.
169
 
                                // If we have a commit request from a valid sender, there should
170
 
                                // be something in the receive queue to process.  However, 
171
 
                                // if a client is buggy or has managed to trick us into accepting
172
 
                                // a commit, we should handle the event gracefully.
173
 
                                g_warning("Processing commit, but no changes to commit were found; ignoring commit event.");
174
 
 
175
 
                                // Remove this sender from the commit list.  If they want to commit
176
 
                                // later, they can.
177
 
                                rcq.pop_front();
178
 
                                return true;
179
 
                        }
180
 
                } else {
181
 
                        // If the receive queue returned is NULL, then we don't know about
182
 
                        // this sender.  Remove the sender from the commit list.
183
 
                        g_warning("Attempting to process commit from unknown sender; ignoring.");
184
 
                        rcq.pop_front();
185
 
                        return true;
186
 
                }
187
 
        } else {
188
 
                return true;
189
 
        }
190
 
}
191
 
 
192
 
}
193
 
 
194
 
}
195
 
 
196
 
 
197
 
/*
198
 
  Local Variables:
199
 
  mode:c++
200
 
  c-file-style:"stroustrup"
201
 
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
202
 
  indent-tabs-mode:nil
203
 
  fill-column:99
204
 
  End:
205
 
*/
206
 
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :