// should we move this to AbiCollab.cpp ?
void AbiCollabSessionManager::updateAcl(AbiCollab* pSession, AccountHandler* pAccount, const std::vector<std::string> vAcl)
{
UT_return_if_fail(pSession);
UT_return_if_fail(pAccount);
// check if all current collaborators are still allowed to collaborate; if not,
// then remove them from the session
const std::map<BuddyPtr, std::string> collaborators = pSession->getCollaborators();
for (std::map<BuddyPtr, std::string>::const_iterator cit = collaborators.begin(); cit != collaborators.end(); cit++)
{
BuddyPtr pBuddy = (*cit).first;
UT_continue_if_fail(pBuddy);
AccountHandler* pBuddyAccount = pBuddy->getHandler();
UT_continue_if_fail(pBuddyAccount);
UT_continue_if_fail(pBuddyAccount == pAccount);
if (!pBuddyAccount->hasAccess(vAcl, pBuddy))
{
// this current collaborator has been banned from the session, so
// disconnect him
UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED);
}
}
// set the new ACL on the account handler
pAccount->setAcl(pSession, vAcl);
// set the new access control list on the session
pSession->setAcl(vAcl);
}
void AbiCollab::_restartAsMaster()
{
UT_DEBUGMSG(("AbiCollab::_restartAsMaster()\n"));
m_Import.masterInit();
m_Export.masterInit();
// the session controller will never have to revert individual changerecords,
// so we can re-enable changerecord coalescing
// FIXME: enable this
//pDoc->setCoalescingMask(true);
// inform everyone that we can restart this session
SessionReconnectAckPacket srap(m_sId, m_pDoc->getDocUUIDString(), m_pDoc->getCRNumber());
for (std::map<BuddyPtr, std::string>::iterator it = m_vCollaborators.begin(); it != m_vCollaborators.end(); it++)
{
BuddyPtr pBuddy = (*it).first;
UT_continue_if_fail(pBuddy);
AccountHandler* pHandler = pBuddy->getHandler();
UT_continue_if_fail(pHandler);
pHandler->send(&srap, pBuddy);
}
// we're the master now!
m_eTakeoveState = STS_NONE;
_pushOutgoingQueue();
}
void TCPAccountHandler::_handleMessages(boost::shared_ptr<Session> session_ptr)
{
UT_DEBUGMSG(("TCPAccountHandler::_handleMessages()\n"));
UT_return_if_fail(session_ptr);
// handle all packets waiting in our queue
int packet_size;
char* packet_data;
while (session_ptr->pop(packet_size, &packet_data))
{
// get the buddy for this session
TCPBuddyPtr pBuddy = _getBuddy(session_ptr);
UT_continue_if_fail(pBuddy); // TODO: shouldn't we just disconnect here?
// construct the packet
// FIXME: inefficient copying of data
std::string packet_str(packet_size, ' ');
memcpy(&packet_str[0], packet_data, packet_size);
FREEP(packet_data);
Packet* pPacket = _createPacket(packet_str, pBuddy);
UT_continue_if_fail(pPacket); // TODO: shouldn't we just disconnect here?
// handle!
handleMessage(pPacket, pBuddy);
}
}
void AbiCollab::initiateSessionTakeover(BuddyPtr pNewMaster)
{
UT_return_if_fail(pNewMaster);
UT_DEBUGMSG(("AbiCollab::initiateSessionTakeover() - pNewMaster: %s\n", pNewMaster->getDescriptor(true).utf8_str()));
AbiCollabSessionManager* pManager = AbiCollabSessionManager::getManager();
UT_return_if_fail(pManager);
// this could lead to us never exiting; add a timeout or something somewhere :)
pManager->beginAsyncOperation(this);
// NOTE: we only allow slaves in the session takeover process
// that are on the same account as the proposed master is. The
// others are dropped from the session. At least for now.
// TODO: implement me
// reset any old session takeover state
m_bProposedController = false;
m_pProposedController = pNewMaster;
m_vApprovedReconnectBuddies.clear();
m_mAckedSessionTakeoverBuddies.clear();
m_bSessionFlushed = false;
if (m_vOutgoingQueue.size() > 0)
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
m_vOutgoingQueue.clear();
// send a SessionTakeoverRequest packet to the new master
std::vector<std::string> buddyIdentifiers;
for (std::map<BuddyPtr, std::string>::iterator it = m_vCollaborators.begin(); it != m_vCollaborators.end(); it++)
{
BuddyPtr pBuddy = (*it).first;
UT_continue_if_fail(pBuddy);
if (pNewMaster != pBuddy)
buddyIdentifiers.push_back(pBuddy->getDescriptor(true).utf8_str());
}
SessionTakeoverRequestPacket strp_promote(m_sId, m_pDoc->getDocUUIDString(), true, buddyIdentifiers);
pNewMaster->getHandler()->send(&strp_promote, pNewMaster);
// send a SessionTakeoverRequest packet to the other slaves (if any)
buddyIdentifiers.clear();
buddyIdentifiers.push_back(pNewMaster->getDescriptor(true).utf8_str());
SessionTakeoverRequestPacket strp_normal(m_sId, m_pDoc->getDocUUIDString(), false, buddyIdentifiers);
for (std::map<BuddyPtr, std::string>::iterator it = m_vCollaborators.begin(); it != m_vCollaborators.end(); it++)
{
BuddyPtr pBuddy = (*it).first;
UT_continue_if_fail(pBuddy);
if (pNewMaster != pBuddy)
pBuddy->getHandler()->send(&strp_normal, pBuddy);
}
m_eTakeoveState = STS_SENT_TAKEOVER_REQUEST;
}
/*!
* Send this packet. Note, the specified packet does still belong to the calling class.
* So if we want to store it (for masking), we HAVE to clone it first
*/
void AbiCollab::push(SessionPacket* pPacket)
{
UT_DEBUGMSG(("AbiCollab::push()\n"));
UT_return_if_fail(pPacket);
if (m_bIsReverting)
{
UT_DEBUGMSG(("This packet was generated by a local revert triggerd in the import; dropping on the floor!\n"));
return;
}
if (m_bExportMasked)
{
m_vecMaskedPackets.push_back(static_cast<SessionPacket*>(pPacket->clone())); // TODO: make this a shared ptr, so we don't need to clone the packet
return;
}
if (!isLocallyControlled() && m_eTakeoveState != STS_NONE)
{
// TODO: revert ack packets should still go to old master
// (or be dropped on the floor, as he probably is not even around anymore)
UT_DEBUGMSG(("We're in the middle of a session takeover; holding on to the packet until the new master is ready"));
m_vOutgoingQueue.push_back(static_cast<SessionPacket*>(pPacket->clone())); // TODO: make this a shared ptr, so we don't need to clone the packet
return;
}
// record
if (m_pRecorder)
m_pRecorder->storeOutgoing( const_cast<const SessionPacket*>( pPacket ) );
// TODO: this could go in the session manager
UT_DEBUGMSG(("Pusing packet to %d collaborators\n", m_vCollaborators.size()));
for (std::map<BuddyPtr, std::string>::iterator it = m_vCollaborators.begin(); it != m_vCollaborators.end(); it++)
{
BuddyPtr pCollaborator = (*it).first;
UT_continue_if_fail(pCollaborator);
UT_DEBUGMSG(("Pushing packet to collaborator with descriptor: %s\n", pCollaborator->getDescriptor(true).utf8_str()));
AccountHandler* pHandler = pCollaborator->getHandler();
UT_continue_if_fail(pHandler);
// overwrite remote revision for this collaborator
_fillRemoteRev(pPacket, pCollaborator);
// send!
bool res = pHandler->send(pPacket, pCollaborator);
if (!res)
{
UT_DEBUGMSG(("Error sending a packet!\n"));
}
}
}
void TCPAccountHandler::handleEvent(boost::shared_ptr<Session> session_ptr)
{
UT_DEBUGMSG(("TCPAccountHandler::handleEvent()\n"));
UT_return_if_fail(session_ptr);
AbiCollabSessionManager* pManager = AbiCollabSessionManager::getManager();
UT_return_if_fail(pManager);
// make sure we have handled _all_ packets in the queue before checking
// the disconnected status
bool disconnected = !session_ptr->isConnected();
_handleMessages(session_ptr);
// check the connection status
if (disconnected)
{
UT_DEBUGMSG(("Socket is not connected anymore!\n"));
// drop all buddies that were on this connection
std::map<TCPBuddyPtr, boost::shared_ptr<Session> >::iterator next;
for (std::map<TCPBuddyPtr, boost::shared_ptr<Session> >::iterator it = m_clients.begin(); it != m_clients.end(); it = next)
{
next = it;
next++;
UT_continue_if_fail((*it).first);
UT_continue_if_fail((*it).second);
TCPBuddyPtr pB = (*it).first;
if ((*it).second == session_ptr)
{
UT_DEBUGMSG(("Lost connection to %s buddy %s:%s\n", getProperty("server") == "" ? "client" : "server", pB->getAddress().c_str(), pB->getPort().c_str()));
// drop this buddy from all sessions
pManager->removeBuddy(pB, false);
// erase the buddy <-> session mapping
m_clients.erase(it);
deleteBuddy(pB);
}
}
// if we were connected to a server, then we are basically disconnected now
if (getProperty("server") != "")
disconnect();
}
// check other things here if needed...
}
bool AbiCollabSessionManager::addAccount(AccountHandler* pHandler)
{
UT_return_val_if_fail(pHandler, false);
bool bUnique = true;
for (UT_uint32 i = 0; i < m_vecAccounts.size() && bUnique; i++)
{
UT_continue_if_fail(m_vecAccounts[i]);
if (pHandler->getStorageType() == m_vecAccounts[i]->getStorageType())
{
// Accounts are of same backend - compare if equal
bUnique = !((*pHandler) == (*m_vecAccounts[i]));
}
}
if (bUnique)
{
m_vecAccounts.push_back(pHandler);
}
else
{
_deleteAccount(pHandler);
UT_DEBUGMSG(("User attempted to add duplicate account - request ignored.\n"));
}
return bUnique;
}
void AbiCollab::_setDocument(PD_Document* pDoc)
{
UT_DEBUGMSG(("AbiCollab::setDocument()\n"));
UT_return_if_fail(pDoc);
AbiCollabSessionManager* pManager = AbiCollabSessionManager::getManager();
UT_return_if_fail(pManager);
// assume clean state
UT_return_if_fail(m_iDocListenerId==0);
m_pDoc = pDoc;
// register ourselves as a mouse listener to all frames showing this document
for (UT_sint32 i = 0; i < XAP_App::getApp()->getFrameCount(); i++)
{
XAP_Frame* pFrame = XAP_App::getApp()->getFrame(i);
UT_continue_if_fail(pFrame);
if (pFrame->getCurrentDoc() == m_pDoc)
{
// this frame is showing our document, attach a mouse listener to it
EV_Mouse* pMouse = pFrame->getMouse();
if (pMouse)
m_mMouseListenerIds[pMouse] = pMouse->registerListener(this);
}
}
// add the new export listeners
UT_uint32 lid = 0;
pDoc->addListener(static_cast<PL_Listener *>(&m_Export), &lid);
_setDocListenerId(lid);
UT_DEBUGMSG(("Added document listener %d\n", lid));
}
static void
handle_dbus_channel(TpSimpleHandler* /*handler*/,
TpAccount* /*account*/,
TpConnection* /*connection*/,
GList* channels,
GList* /*requests*/,
gint64 /*user_action_time*/,
TpHandleChannelsContext* context,
gpointer user_data)
{
UT_DEBUGMSG(("handle_dbus_channel()\n"));
TelepathyAccountHandler* pHandler = reinterpret_cast<TelepathyAccountHandler*>(user_data);
UT_return_if_fail(pHandler);
for (GList* chan = channels; chan; chan = chan->next)
{
TpChannel* channel = TP_CHANNEL(chan->data);
UT_continue_if_fail(channel);
UT_DEBUGMSG((">>>>> incoming dbus channel: %s\n", tp_channel_get_identifier(channel)));
if (tp_channel_get_channel_type_id(channel) != TP_IFACE_QUARK_CHANNEL_TYPE_DBUS_TUBE)
continue;
/* accept the channel */
tp_cli_channel_type_dbus_tube_call_accept(channel, -1,
TP_SOCKET_ACCESS_CONTROL_LOCALHOST,
tube_accept_cb, user_data, NULL, NULL);
}
tp_handle_channels_context_accept(context);
}
void AccountHandler::signal(const Event& event, BuddyPtr pSource)
{
UT_DEBUGMSG(("AccountHandler::signal()\n"));
// we will not forward an event over this account that came from another
// account: if you do that, then you very easily get packets running around
// forever.
if (pSource && pSource->getHandler() != this)
return;
// broadcast this event over our network (if applicable for each message type)
const std::vector<BuddyPtr> vRecipients =
(event.isBroadcast() ? getBuddies() : event.getRecipients());
for (std::vector<BuddyPtr>::const_iterator cit = vRecipients.begin(); cit != vRecipients.end(); cit++)
{
BuddyPtr pRecipient = *cit;
UT_continue_if_fail(pRecipient);
if (!pSource || (pSource != pRecipient))
{
send(&event, pRecipient);
}
else
{
// the event originated from this buddy, so make sure not to send it
// back to him, as it would result in a broadcast storm and
// kill the network really fast
}
}
}
/**
* Link list level styles to the text styles that they refer to.
*/
void ODi_Office_Styles::_linkListStyles() const
{
UT_sint32 count2;
ODi_ListLevelStyle* pLevelStyle;
ODi_Style_List* pListStyle;
const ODi_Style_Style* pStyle;
for(ListMap::const_iterator iter = m_listStyles.begin();
iter != m_listStyles.end(); ++iter) {
pListStyle = iter->second;
UT_continue_if_fail(pListStyle);
count2 = pListStyle->getLevelCount();
// List levels start from 1.
for (UT_sint32 j = 1; j <= count2; j++) {
pLevelStyle = pListStyle->getLevelStyle(j);
pStyle = getTextStyle(
pLevelStyle->getTextStyleName()->utf8_str(), false);
pLevelStyle->setTextStyle(pStyle);
}
}
}
void TCPAccountHandler::addBuddy(BuddyPtr pBuddy)
{
UT_DEBUGMSG(("TCPAccountHandler::addBuddy()\n"));
UT_return_if_fail(pBuddy);
AbiCollabSessionManager* pManager = AbiCollabSessionManager::getManager();
UT_return_if_fail(pManager);
if (getProperty("allow-all") == "true")
{
const UT_GenericVector<AbiCollab *> pSessions = pManager->getSessions();
for (UT_sint32 i = 0; i < pSessions.size(); i++)
{
AbiCollab* pSession = pSessions.getNthItem(i);
UT_continue_if_fail(pSession);
if (pSession->getAclAccount() != this)
continue;
pSession->appendAcl(pBuddy->getDescriptor(false).utf8_str());
}
}
AccountHandler::addBuddy(pBuddy);
}
static void
list_contacts_for_connection_cb(TpConnection* /*connection*/,
guint n_contacts,
TpContact * const *contacts,
guint /*n_invalid*/,
const TpHandle* /*invalid*/,
const GError* error,
gpointer user_data,
GObject* /*weak_object*/)
{
UT_DEBUGMSG(("list_contacts_for_connection_cb()\n"));
UT_return_if_fail(!error);
TelepathyAccountHandler* pHandler = reinterpret_cast<TelepathyAccountHandler*>(user_data);
UT_return_if_fail(pHandler);
UT_DEBUGMSG(("Got %d contacts!\n", n_contacts));
for (UT_uint32 i = 0; i < n_contacts; i++)
{
TpContact* contact = contacts[i];
UT_continue_if_fail(contact);
UT_DEBUGMSG(("Alias: '%s'\n", tp_contact_get_alias(contact)));
pHandler->addContact(contact);
}
}
bool XAP_App::updateClones(XAP_Frame * pFrame)
{
UT_return_val_if_fail(pFrame,false);
UT_ASSERT(pFrame->getViewNumber() > 0);
// locate vector of this frame's clones
UT_GenericVector<XAP_Frame*>* pEntry = m_hashClones.pick(pFrame->getViewKey());
UT_ASSERT_HARMLESS(pEntry);
if (pEntry)
{
UT_GenericVector<XAP_Frame*>* pvClones = pEntry;
UT_return_val_if_fail(pvClones,false);
UT_uint32 count = pvClones->getItemCount();
UT_ASSERT(count > 0);
XAP_Frame * f = NULL;
for (UT_uint32 j=0; j<count; j++)
{
f = pvClones->getNthItem(j);
UT_continue_if_fail(f);
f->updateTitle();
}
}
return true;
}
bool XMPPAccountHandler::send(const Packet* pPacket)
{
UT_return_val_if_fail(pPacket, false);
const std::string resource = getProperty("resource");
// make to-be-send-stream once
std::string data;
_createPacketStream(data, pPacket);
// XMPP doesn't like binary strings, base64 encode them
guint8* base64data = gsf_base64_encode_simple(reinterpret_cast<guint8*>(&data[0]), data.size());
UT_return_val_if_fail(base64data, false);
for (std::vector<BuddyPtr>::iterator it = getBuddies().begin(); it != getBuddies().end(); it++)
{
XMPPBuddyPtr pBuddy = boost::static_pointer_cast<XMPPBuddy>(*it);
UT_continue_if_fail(pBuddy);
if (!_send(reinterpret_cast<char*>(base64data), pBuddy))
{
UT_DEBUGMSG(("Error while sending message to '%s'\n", pBuddy->getAddress().c_str()));
}
}
g_free(base64data);
return true;
}
void AbiCollabSessionManager::disconnectSessions()
{
for(UT_sint32 i = 0; i < m_vecSessions.getItemCount(); i++)
{
AbiCollab* pSession = m_vecSessions.getNthItem(i);
UT_continue_if_fail(pSession);
disconnectSession(pSession);
}
}
void AbiCollabSessionManager::removeBuddy(BuddyPtr pBuddy, bool graceful)
{
UT_return_if_fail(pBuddy);
UT_DEBUGMSG(("Dropping buddy '%s' from all sessions\n", pBuddy->getDescription().utf8_str()));
// TODO: should we send out events for every buddy we drop, or session
// we delete?
for (UT_sint32 i = m_vecSessions.getItemCount() - 1; i >= 0; i--)
{
AbiCollab* pSession = m_vecSessions.getNthItem(i);
UT_continue_if_fail(pSession);
if (pSession->isLocallyControlled())
{
pSession->removeCollaborator(pBuddy);
}
else
{
// we don't control this session, meaning we can drop it completely
// if this buddy controlled it
// TODO: when we allow more than 1 buddy in a non-locally controlled,
// then remove it from that list here
if (pSession->isController(pBuddy))
{
UT_DEBUGMSG(("This buddy controlled a session, destroying the session...\n"));
std::string docName = pSession->getDocument()->getFilename();
if (docName == "")
docName = "Untitled"; // TODO: fetch the title from the frame somehow (which frame?) - MARCM
destroySession(pSession);
if (!graceful)
{
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
UT_continue_if_fail(pFrame);
// TODO: make this localizable
UT_UTF8String msg;
UT_UTF8String_sprintf(msg, "You've been disconnected from buddy %s. The collaboration session for document %s has been stopped.", pBuddy->getDescription().utf8_str(), docName.c_str());
pFrame->showMessageBox(msg.utf8_str(), XAP_Dialog_MessageBox::b_O, XAP_Dialog_MessageBox::a_OK);
}
}
}
}
}
void AbiCollabSessionManager::unregisterSniffers(void)
{
for (UT_uint32 i = 0; i < m_vImpSniffers.size(); i++)
{
IE_ImpSniffer* pSniffer = m_vImpSniffers[i];
UT_continue_if_fail(pSniffer);
IE_Imp::unregisterImporter(pSniffer);
delete pSniffer;
}
m_vImpSniffers.clear();
}
XMPPBuddyPtr XMPPAccountHandler::_getBuddy(const std::string& from_address)
{
for (std::vector<BuddyPtr>::iterator it = getBuddies().begin(); it != getBuddies().end(); it++)
{
XMPPBuddyPtr pBuddy = boost::static_pointer_cast<XMPPBuddy>(*it);
UT_continue_if_fail(pBuddy);
if (pBuddy->getAddress() == from_address)
return pBuddy;
}
return XMPPBuddyPtr();
}
bool AccountHandler::hasSession(const UT_UTF8String& sSessionId)
{
for (std::vector<BuddyPtr>::iterator it = m_vBuddies.begin(); it != m_vBuddies.end(); it++)
{
BuddyPtr pBuddy = *it;
UT_continue_if_fail(pBuddy);
if (pBuddy->getDocHandle(sSessionId))
return true;
}
return false;
}
RealmBuddyPtr RealmConnection::getBuddy(UT_uint8 realm_connection_id)
{
for (std::vector<RealmBuddyPtr>::iterator it = m_buddies.begin(); it != m_buddies.end(); it++)
{
UT_continue_if_fail(*it);
if ((*it)->realm_connection_id() == realm_connection_id)
{
return *it;
}
}
return RealmBuddyPtr();
}
TelepathyBuddyPtr TelepathyAccountHandler::_getBuddy(TelepathyBuddyPtr pBuddy)
{
UT_return_val_if_fail(pBuddy, TelepathyBuddyPtr());
for (std::vector<BuddyPtr>::iterator it = getBuddies().begin(); it != getBuddies().end(); it++)
{
TelepathyBuddyPtr pB = boost::static_pointer_cast<TelepathyBuddy>(*it);
UT_continue_if_fail(pB);
if (pBuddy->equals(pB))
return pB;
}
return TelepathyBuddyPtr();
}
TelepathyChatroomPtr TelepathyAccountHandler::_getChatroom(const UT_UTF8String& sSessionId)
{
for (std::vector<TelepathyChatroomPtr>::iterator it = m_chatrooms.begin(); it != m_chatrooms.end(); it++)
{
TelepathyChatroomPtr pChatroom = *it;
UT_continue_if_fail(pChatroom);
if (pChatroom->getSessionId() == sSessionId)
return pChatroom;
}
return TelepathyChatroomPtr();
}
void TelepathyAccountHandler::_inviteBuddies(TelepathyChatroomPtr pChatroom, const std::vector<std::string>& vAcl)
{
UT_return_if_fail(pChatroom);
std::vector<TelepathyBuddyPtr> buddies = _getBuddies(vAcl);
// add the buddies in the acl list to the room invitee list
for (std::vector<TelepathyBuddyPtr>::iterator it = buddies.begin(); it != buddies.end(); it++)
{
UT_continue_if_fail(*it);
pChatroom->queueInvite(*it);
}
}
void AP_UnixDialog_CollaborationShare::_populateWindowData()
{
AbiCollabSessionManager* pManager = AbiCollabSessionManager::getManager();
UT_return_if_fail(pManager);
// populate the account combobox
GtkListStore* store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
GtkTreeIter iter;
AccountHandler* pShareeableAcount = _getShareableAccountHandler();
if (pShareeableAcount)
{
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
0, pShareeableAcount->getDescription().utf8_str(),
1, pShareeableAcount,
-1);
gtk_widget_set_sensitive(m_wAccount, false);
}
else
{
for (std::vector<AccountHandler*>::const_iterator cit = pManager->getAccounts().begin(); cit != pManager->getAccounts().end(); cit++)
{
AccountHandler* pAccount = *cit;
UT_continue_if_fail(pAccount);
if (!pAccount->isOnline() || !pAccount->canManuallyStartSession())
continue;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
0, pAccount->getDescription().utf8_str(),
1, pAccount,
-1);
}
gtk_widget_set_sensitive(m_wAccount, true);
}
m_pAccountModel = GTK_TREE_MODEL (store);
gtk_combo_box_set_model(GTK_COMBO_BOX(m_wAccount), m_pAccountModel);
// if we have at least one account handler, then make sure the first one is selected
if (pManager->getRegisteredAccountHandlers().size() > 0)
{
gtk_combo_box_set_active(GTK_COMBO_BOX(m_wAccount), 0);
}
else
{
// nope, we don't have any account handler :'-(
gtk_combo_box_set_active(GTK_COMBO_BOX(m_wAccount), -1);
}
}
bool AbiCollabSessionManager::destroyAccount(AccountHandler* pHandler)
{
UT_return_val_if_fail(pHandler, false);
for (UT_uint32 i = 0; i < m_vecAccounts.size(); i++)
{
UT_continue_if_fail(m_vecAccounts[i]);
if (pHandler == m_vecAccounts[i])
{
UT_DEBUGMSG(("Destroying account handler %s\n", pHandler->getDescription().utf8_str()));
// TODO: if a number of buddies are connected, then we should ask for confirmation
// drop all buddies that belong to the account that is being deleted
// from all active sessions
for (UT_sint32 j = 0; j < m_vecSessions.getItemCount(); j++)
{
AbiCollab* pSession = m_vecSessions.getNthItem(j);
UT_continue_if_fail(pSession);
// There can only be buddies from 1 account in an active session these days/
// That means that if this session's account is the account we are destroying,
// then we can kill off the entire session. Do nothing otherwise.
if (pSession->getAclAccount() == pHandler)
{
UT_DEBUGMSG(("Session %s is running on this account, destroying it!\n", pSession->getSessionId().utf8_str()));
destroySession(pSession);
}
}
m_vecAccounts.erase(m_vecAccounts.begin() + i, m_vecAccounts.begin() + i + 1);
_deleteAccount(pHandler);
return true;
}
}
return false;
}
void RealmConnection::removeBuddy(UT_uint8 realm_connection_id)
{
for (std::vector<RealmBuddyPtr>::iterator it = m_buddies.begin(); it != m_buddies.end(); it++)
{
UT_continue_if_fail(*it);
if ((*it)->realm_connection_id() == realm_connection_id)
{
m_buddies.erase(it);
return;
}
}
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
void AP_UnixDialog_CollaborationShare::_populateBuddyModel(bool refresh)
{
UT_DEBUGMSG(("AP_UnixDialog_CollaborationShare::_populateBuddyModel()\n"));
UT_return_if_fail(m_pBuddyModel);
AbiCollabSessionManager* pManager = AbiCollabSessionManager::getManager();
UT_return_if_fail(pManager);
AccountHandler* pHandler = _getActiveAccountHandler();
UT_return_if_fail(pHandler);
if (refresh)
{
// signal the account to refresh its buddy list ...
pHandler->getBuddiesAsync(); // this function is really sync() atm; we need to rework this dialog to make it proper async
// fetch the current ACL
m_vAcl = _getSessionACL();
}
// clear out the old contents, if any
_freeBuddyList();
GtkTreeIter iter;
for (UT_uint32 i = 0; i < pHandler->getBuddies().size(); i++)
{
BuddyPtr pBuddy = pHandler->getBuddies()[i];
UT_continue_if_fail(pBuddy);
if (!pBuddy->getHandler()->canShare(pBuddy))
{
UT_DEBUGMSG(("Not allowed to share with buddy: %s\n", pBuddy->getDescription().utf8_str()));
continue;
}
// crap, we can't store shared pointers in the list store; use a
// hack to do it (which kinda defies the whole shared pointer thingy,
// but alas...)
BuddyPtrWrapper* pWrapper = new BuddyPtrWrapper(pBuddy);
gtk_list_store_append (m_pBuddyModel, &iter);
gtk_list_store_set (m_pBuddyModel, &iter,
SHARE_COLUMN, _populateShareState(pBuddy),
DESC_COLUMN, pBuddy->getDescription().utf8_str(),
BUDDY_COLUMN, pWrapper,
-1);
}
gtk_widget_show_all(m_wBuddyTree);
}
UT_sint32 GlobSessionPacket::getRemoteRev(void) const
{
for (size_t i = 0; i < m_pPackets.size(); i++)
{
UT_continue_if_fail(m_pPackets[i]);
SessionPacket* pPacket = m_pPackets[i];
if (pPacket->getClassType() >= _PCT_FirstChangeRecord && pPacket->getClassType() <= _PCT_LastChangeRecord)
{
ChangeRecordSessionPacket* crp = static_cast<ChangeRecordSessionPacket*>( pPacket );
return crp->getRemoteRev();
}
}
UT_return_val_if_fail(false, 0);
}
void AccountHandler::deleteBuddy(BuddyPtr pBuddy)
{
UT_return_if_fail(pBuddy);
for (std::vector<BuddyPtr>::iterator it = m_vBuddies.begin(); it != m_vBuddies.end(); it++)
{
BuddyPtr pB = *it;
UT_continue_if_fail(pB);
if (pB == pBuddy)
{
m_vBuddies.erase(it);
return;
}
}
UT_ASSERT_HARMLESS(UT_NOT_REACHED);
}