/** * Whiteboard session manager * Methods for establishing connections and notifying the user of events * * Authors: * David Yip <yipdw@rose-hulman.edu> * * Copyright (c) 2005 Authors * * Released under GNU GPL, read the file 'COPYING' for more information */ #include "util/ucompose.hpp" #include <glibmm/i18n.h> #include <gtkmm/dialog.h> #include <gtkmm/messagedialog.h> #include "desktop.h" #include "file.h" #include "document.h" #include "xml/repr.h" #include "jabber_whiteboard/defines.h" #include "jabber_whiteboard/typedefs.h" #include "jabber_whiteboard/node-tracker.h" #include "jabber_whiteboard/chat-handler.h" #include "jabber_whiteboard/message-queue.h" #include "jabber_whiteboard/session-manager.h" #include "jabber_whiteboard/invitation-confirm-dialog.h" namespace Inkscape { namespace Whiteboard { void 00037 SessionManager::sendRequestToUser(std::string const& recipientJID) { /* Glib::ustring doccopy; if (document != NULL) { doccopy = *document; } */ this->session_data->status.set(WAITING_FOR_INVITE_RESPONSE, 1); this->sendMessage(CONNECT_REQUEST_USER, 0, "", recipientJID.c_str(), false); } void 00050 SessionManager::sendRequestToChatroom(Glib::ustring const& server, Glib::ustring const& chatroom, Glib::ustring const& handle, Glib::ustring const& password) { // We do not yet use the Basic MUC Protocol for connection establishment etc // <http://www.jabber.org/jeps/jep-0045.html>. The protocol we use is the // old GroupChat system; extension to MUC is TODO // Compose room@service/nick string for "to" field Glib::ustring dest = String::ucompose("%1@%2/%3", chatroom, server, handle); LmMessage* presence_req = lm_message_new(dest.data(), LM_MESSAGE_TYPE_PRESENCE); // Add 'from' attribute LmMessageNode* preq_root = lm_message_get_node(presence_req); lm_message_node_set_attribute(preq_root, "from", lm_connection_get_jid(this->session_data->connection)); // Add <x xmlns='http://jabber.org/protocol/muc/' /> // (Not anymore: we don't speak it! -- yipdw) LmMessageNode* xmlns_node = lm_message_node_add_child(preq_root, "x", ""); lm_message_node_set_attribute(xmlns_node, "xmlns", "http://jabber.org/protocol/muc/"); // If a password was supplied, add it to xmlns_node if (password != NULL) { lm_message_node_add_child(xmlns_node, "password", password.c_str()); } // Create chat message handler and node tracker if (!this->_myChatHandler) { this->_myChatHandler = new ChatMessageHandler(this); } // Flag ourselves as connecting to a chatroom (but not yet connected) this->session_data->status.set(CONNECTING_TO_CHAT, 1); // Send the message GError *error = NULL; if (!lm_connection_send(this->session_data->connection, presence_req, &error)) { g_error("Presence message could not be sent to %s: %s", dest.data(), error->message); this->session_data->status.set(CONNECTING_TO_CHAT, 0); } this->session_data->chat_handle = handle; this->session_data->chat_server = server; this->session_data->chat_name = chatroom; this->setRecipient(String::ucompose("%1@%2", chatroom, server).data()); lm_message_unref(presence_req); } void 00099 SessionManager::sendConnectRequestResponse(char const* recipientJID, gboolean accepted_request) { if (accepted_request == TRUE) { this->setRecipient(recipientJID); this->session_data->status.set(IN_WHITEBOARD, 1); } this->sendMessage(CONNECT_REQUEST_RESPONSE_USER, accepted_request, "", recipientJID, false); } // When this method is invoked, it means that the user has received an invitation from another peer // to engage in a whiteboard session (i.e. 1:1 communication). The user may accept or reject this invitation. void 00112 SessionManager::receiveConnectRequest(gchar const* requesterJID) { int x, y; Gdk::ModifierType mt; Gdk::Display::get_default()->get_pointer(x, y, mt); if (mt) { // Attach a polling timeout this->_notify_incoming_request = Glib::signal_timeout().connect(sigc::bind< 0 >(sigc::mem_fun(*this, &SessionManager::_pollReceiveConnectRequest), requesterJID), 50); return; } if (this->session_data->status[IN_WHITEBOARD]) { this->sendMessage(ALREADY_IN_SESSION, 0, "", requesterJID, false); } // Check to see if the user made any modifications to this document. If so, // we want to give them the option of (1) letting us clear their document or (2) // opening a new, blank document for the whiteboard session. Glib::ustring primary = "<span weight=\"bold\" size=\"larger\">" + String::ucompose(_("<b>%1</b> has invited you to a whiteboard session."), requesterJID) + "</span>\n\n"; Glib::ustring title = String::ucompose(_("Incoming whiteboard invitation from %1"), requesterJID); if (sp_document_repr_root(this->_myDoc)->attribute("sodipodi:modified") == NULL) { primary += String::ucompose(_("Do you wish to accept <b>%1</b>'s whiteboard session invitation?"), requesterJID); } else { primary += String::ucompose(_("Would you like to accept %1's invitation in a new document window?\nAccepting the invitation in your current window will discard unsaved changes."), requesterJID); } // Construct confirmation dialog InvitationConfirmDialog dialog(primary); dialog.add_button(_("Accept invitation"), ACCEPT_INVITATION); dialog.add_button(_("Decline invitation"), DECLINE_INVITATION); dialog.add_button(_("Accept invitation in new document window"), ACCEPT_INVITATION_IN_NEW_WINDOW); bool undecided = true; InvitationResponses resp = static_cast< InvitationResponses >(dialog.run()); while(undecided) { if (resp == ACCEPT_INVITATION) { undecided = false; this->clearDocument(); // Create a receive queue for the initiator of this request this->session_data->receive_queues[requesterJID] = new ReceiveMessageQueue(this); this->setupInkscapeInterface(); if (dialog.useSessionFile()) { this->session_data->sessionFile = dialog.getSessionFilePath(); this->_tryToStartLog(); } this->sendConnectRequestResponse(requesterJID, TRUE); } else if (resp == ACCEPT_INVITATION_IN_NEW_WINDOW) { SPDesktop* newdesktop = sp_file_new_default(); if (newdesktop != NULL) { undecided = false; // Swap desktops around // Destroy the new desktop's session manager and add this one in delete newdesktop->_whiteboard_session_manager; newdesktop->_whiteboard_session_manager = this; // Assign a new session manager to our old desktop this->_myDesktop->_whiteboard_session_manager = new SessionManager(this->_myDesktop); // Reset our desktop and document pointers this->setDesktop(newdesktop); // Prepare document and send acceptance notification this->session_data->receive_queues[requesterJID] = new ReceiveMessageQueue(this); this->clearDocument(); this->setupInkscapeInterface(); if (dialog.useSessionFile()) { this->session_data->sessionFile = dialog.getSessionFilePath(); this->_tryToStartLog(); } this->sendConnectRequestResponse(requesterJID, TRUE); } else { // We could not create a new desktop; ask the user if she or he wants to // replace the current document and accept the invitation, or reject the invitation. // TRANSLATORS: %1 is a userid here Glib::ustring msg = "<span weight=\"bold\" size=\"larger\">" + String::ucompose(_("A new document window could not be opened for a whiteboard session with <b>%1</b>"), requesterJID) + ".</span>\n\nWould you like to accept the whiteboard connection in the active document or refuse the invitation?"; InvitationConfirmDialog replace_dialog(msg); dialog.add_button(_("Accept invitation"), ACCEPT_INVITATION); dialog.add_button(_("Decline invitation"), DECLINE_INVITATION); resp = static_cast< InvitationResponses >(dialog.run()); } } else { undecided = false; this->sendMessage(CONNECT_REQUEST_REFUSED_BY_PEER, 0, "", requesterJID, false); } } } // When this method is invoked, it means that the other peer // has accepted our request. void 00212 SessionManager::receiveConnectRequestResponse(InvitationResponses response, std::string& sender) { this->session_data->status.set(WAITING_FOR_INVITE_RESPONSE, 0); switch(response) { case ACCEPT_INVITATION: { // Create a receive queue for the other peer. this->session_data->receive_queues[sender] = new ReceiveMessageQueue(this); KeyToNodeMap newids; NodeToKeyMap newnodes; this->_myTracker = new XMLNodeTracker(this); this->setupInkscapeInterface(); this->_tryToStartLog(); this->resendDocument(this->session_data->recipient, newids, newnodes); this->_myTracker->put(newids, newnodes); // this->_myTracker->dump(); this->setupCommitListener(); break; } case DECLINE_INVITATION: { // TRANSLATORS: %1 is the peer whom refused our invitation. Glib::ustring primary = String::ucompose(_("<span weight=\"bold\" size=\"larger\">The user <b>%1</b> has refused your whiteboard invitation.</span>\n\n"), sender); // TRANSLATORS: %1 is the peer whom refused our invitation, %2 is our Jabber identity. Glib::ustring secondary = String::ucompose(_("You are still connected to a Jabber server as <b>%2</b>, and may send an invitation to <b>%1</b> again, or you may send an invitation to a different user."), sender, lm_connection_get_jid(this->session_data->connection)); Gtk::MessageDialog dialog(primary + secondary, true, Gtk::MESSAGE_INFO, Gtk::BUTTONS_CLOSE, false); dialog.run(); break; } case PEER_ALREADY_IN_SESSION: { // TRANSLATORS: %1 is the peer whom we tried to contact, but is already in a whiteboard session. Glib::ustring primary = String::ucompose(_("<span weight=\"bold\" size=\"larger\">The user <b>%1</b> is already in a whiteboard session.</span>\n\n"), sender); // TRANSLATORS: %1 is the peer whom we tried to contact, but is already in a whiteboard session. Glib::ustring secondary = String::ucompose(_("You are still connected to a Jabber server as <b>%1</b>, and may send an invitation to a different user."), sender); Gtk::MessageDialog dialog(primary + secondary, true, Gtk::MESSAGE_INFO, Gtk::BUTTONS_CLOSE, false); dialog.run(); break; } default: break; } } void 00267 SessionManager::receiveConnectRequestResponseChat(gchar const* recipient) { // When responding to connection request responses in chatrooms, // the responding user is already established in the whiteboard session. // Therefore we do not need to perform any setup of observers or dispatchers; the requesting user // will do that. KeyToNodeMap newids; NodeToKeyMap newnodes; this->resendDocument(recipient, newids, newnodes); } bool SessionManager::_pollReceiveConnectRequest(Glib::ustring const recipientJID) { int x, y; Gdk::ModifierType mt; Gdk::Display::get_default()->get_pointer(x, y, mt); if (mt) { return true; } else { this->receiveConnectRequest(recipientJID.c_str()); return false; } } } } /* Local Variables: mode:c++ c-file-style:"stroustrup" c-file-offsets:((innamespace . 0)(inline-open . 0)) indent-tabs-mode:nil fill-column:99 End: */ // vim: filetype=c++:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :