src/jabber_whiteboard/inkboard-document.cpp

   1 /**
   2  * Inkscape::Whiteboard::InkboardDocument - Inkboard document implementation
   3  *
   4  * Authors:
   5  * David Yip <yipdw@rose-hulman.edu>
   6  *
   7  * Copyright (c) 2005 Authors
   8  *
   9  * Released under GNU GPL, read the file 'COPYING' for more information
  10  */
  11
  12 #include <glib.h>
  13 #include <glibmm.h>
  14
  15 #include "jabber_whiteboard/inkboard-document.h"
  16
  17 #include "xml/simple-session.h"
  18 #include "jabber_whiteboard/inkboard-session.h"
  19 #include "jabber_whiteboard/defines.h"
  20 #include "jabber_whiteboard/session-manager.h"
  21
  22 namespace Inkscape {
  23
  24 namespace Whiteboard {
  25
  26 InkboardDocument::InkboardDocument(int code, State::SessionType type, Glib::ustring const& to) :
  27         XML::SimpleNode(code), _type(type), _recipient(to)
  28 {
  29     _initBindings();
  30 }
  31
  32 void
  33 InkboardDocument::_initBindings()
  34 {
  35     this->_sm = &SessionManager::instance();
  36     this->state = State::INITIAL;
  37     _bindDocument(*this);
  38     _bindLogger(*(new XML::SimpleSession()));
  39 }
  40
  41 void
  42 InkboardDocument::setRecipient(Glib::ustring const& val)
  43 {
  44     this->_recipient = val;
  45 }
  46
  47 Glib::ustring
  48 InkboardDocument::getRecipient() const
  49 {
  50     return this->_recipient;
  51 }
  52
  53 void
  54 InkboardDocument::setSessionId(Glib::ustring const& val)
  55 {
  56     this->_session = val;
  57 }
  58
  59 Glib::ustring
  60 InkboardDocument::getSessionId() const
  61 {
  62     return this->_session;
  63 }
  64
  65 void
  66 InkboardDocument::startSessionNegotiation()
  67 {
  68     if(_type == State::WHITEBOARD_PEER)
  69         sendProtocol(_recipient, Message::PROTOCOL,Message::CONNECT_REQUEST);
  70
  71     else if(_type == State::WHITEBOARD_MUC)
  72     {
  73         // Check that the MUC room is whiteboard enabled, if not no need to send
  74         // anything, just set the room to be whiteboard enabled
  75     }
  76 }
  77
  78 void
  79 InkboardDocument::terminateSession()
  80 {
  81
  82 }
  83
  84 void
  85 InkboardDocument::processInkboardEvent(Message::Wrapper &wrapper, Pedro::Element* data)
  86 {
  87     if(this->handleIncomingState(wrapper,data))
  88     {
  89         if(wrapper == Message::PROTOCOL)
  90         {
  91             Glib::ustring message = data->getFirstChild()->getFirstChild()->getFirstChild()->getName();
  92
  93             if(message == Message::CONNECT_REQUEST)
  94             {
  95                 // An MUC member requesting document
  96
  97             }else if(message == Message::ACCEPT_INVITATION)
  98             {
  99                 // TODO : Would be nice to create the desktop here
 100
 101                 sendProtocol(getRecipient(),Message::PROTOCOL, Message::CONNECTED);
 102                 sendProtocol(getRecipient(),Message::PROTOCOL, Message::DOCUMENT_BEGIN);
 103
 104                 // Send the Document
 105
 106                 sendProtocol(getRecipient(),Message::PROTOCOL, Message::DOCUMENT_END);
 107
 108             }else if(message == Message::DECLINE_INVITATION)
 109             {
 110                 this->_sm->terminateSession(this->getSessionId());
 111             }
 112         }
 113     }else{
 114         g_warning("Recieved Message in invalid state = %d", this->state);
 115         data->print();
 116     }
 117 }
 118
 119 bool
 120 InkboardDocument::sendProtocol(const Glib::ustring &destJid, Message::Wrapper &wrapper,
 121      Message::Message &message)
 122 {
 123     if(this->handleOutgoingState(wrapper,message))
 124     {
 125         char *fmt=
 126             "<message type='%s' from='%s' to='%s'>"
 127                 "<wb xmlns='%s' session='%s'>"
 128                     "<%s>"
 129                         "<%s />"
 130                     "</%s>"
 131                 "</wb>"
 132             "</message>";
 133
 134         if (!_sm->getClient().write(fmt,
 135                 _type.c_str(),_sm->getClient().getJid().c_str(),destJid.c_str(),Vars::INKBOARD_XMLNS.c_str(),
 136                 this->getSessionId().c_str(),wrapper.c_str(),message.c_str(),wrapper.c_str()))
 137             { return false; }
 138
 139         else
 140             { return true; }
 141
 142     }else
 143     {
 144         g_warning("Sending Message in invalid state message=%s , state=%d",message.c_str(),this->state);
 145         return false;
 146     }
 147 }
 148
 149 bool
 150 InkboardDocument::handleOutgoingState(Message::Wrapper &wrapper, Glib::ustring const& message)
 151 {
 152     if(wrapper == Message::PROTOCOL)
 153     {
 154         if(message == Message::CONNECT_REQUEST)
 155             return this->handleState(State::INITIAL,State::AWAITING_INVITATION_REPLY);
 156
 157         else if(message == Message::ACCEPT_INVITATION)
 158             return this->handleState(State::CONNECTING,State::AWAITING_CONNECTED);
 159
 160         else if(message == Message::CONNECTED)
 161             return this->handleState(State::INVITATION_RECIEVED,State::CONNECTED);
 162
 163         else if(message == Message::DOCUMENT_BEGIN)
 164             return this->handleState(State::CONNECTED,State::SYNCHRONISING);
 165
 166         else if(message == Message::DOCUMENT_END) {
 167             return this->handleState(State::SYNCHRONISING,State::IN_WHITEBOARD);
 168         }
 169
 170         else
 171             return false;
 172
 173     } else
 174         if(this->state == State::SYNCHRONISING && wrapper == Message::NEW)
 175             return true;
 176
 177     return this->state == State::IN_WHITEBOARD;
 178 }
 179
 180 bool
 181 InkboardDocument::handleIncomingState(Message::Wrapper &wrapper, Pedro::Element* data)
 182 {
 183     if(wrapper == Message::PROTOCOL)
 184     {
 185         Glib::ustring message = data->getFirstChild()->getFirstChild()->getFirstChild()->getName();
 186
 187         if(message == Message::CONNECT_REQUEST)
 188             return this->handleState(State::INITIAL,State::CONNECTING);
 189         if(message == Message::ACCEPT_INVITATION)
 190             return this->handleState(State::AWAITING_INVITATION_REPLY,State::INVITATION_RECIEVED);
 191
 192         else if(message == Message::CONNECTED)
 193             return this->handleState(State::AWAITING_CONNECTED,State::AWAITING_DOCUMENT_BEGIN);
 194
 195         else if(message == Message::DOCUMENT_BEGIN)
 196             return this->handleState(State::AWAITING_DOCUMENT_BEGIN,State::SYNCHRONISING);
 197
 198         else if(message == Message::DOCUMENT_END)
 199             return this->handleState(State::SYNCHRONISING,State::IN_WHITEBOARD);
 200
 201         else
 202             return false;
 203
 204     } else
 205         if(this->state == State::SYNCHRONISING && wrapper == Message::NEW)
 206             return true;
 207
 208     return this->state == State::IN_WHITEBOARD;
 209 }
 210
 211 bool
 212 InkboardDocument::handleState(State::SessionState expectedState, State::SessionState newState)
 213 {
 214     if(this->state == expectedState)
 215     {
 216         this->state = newState;
 217         return true;
 218     }
 219
 220     return false;
 221 }
 222
 223
 224 } // namespace Whiteboard
 225 } // namespace Inkscape
 226
 227
 228 /*
 229   Local Variables:
 230   mode:c++
 231   c-file-style:"stroustrup"
 232   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 233   indent-tabs-mode:nil
 234   fill-column:99
 235   End:
 236 */
 237 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :