void AccountHandler::_handlePacket(Packet* packet, BuddyPtr buddy)
{
// packet and buddy must always be set
UT_return_if_fail(packet);
UT_return_if_fail(buddy);
// as must the session manager
AbiCollabSessionManager* pManager = AbiCollabSessionManager::getManager();
UT_return_if_fail(pManager);
// manager didn't handle it, see what we can do
switch (packet->getClassType())
{
case PCT_JoinSessionRequestEvent:
{
JoinSessionRequestEvent* jse = static_cast<JoinSessionRequestEvent*>(packet);
// lookup session
AbiCollab* pSession = pManager->getSessionFromSessionId(jse->getSessionId());
UT_return_if_fail(pSession);
// check if this buddy is allowed to access this document
// TODO: this should be done for every session packet, not just join session packets
if (!hasAccess(pSession->getAcl(), buddy))
{
// we should only reach this point if someone is brute forcing trying
// out session IDs while not being on the ACL. Ban this uses.
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
return;
}
// lookup exporter
ABI_Collab_Export* pExport = pSession->getExport();
UT_return_if_fail(pExport);
// lookup adjusts
const UT_GenericVector<ChangeAdjust *>* pExpAdjusts = pExport->getAdjusts();
UT_return_if_fail(pExpAdjusts);
PD_Document* pDoc = pSession->getDocument();
// add this author to the document if we don't recognize him
UT_sint32 iAuthorId = -1;
UT_UTF8String buddyDescriptor = buddy->getDescriptor();
UT_GenericVector<pp_Author*> authors = pDoc->getAuthors();
UT_DEBUGMSG(("Scanning %d authors to see if we recognize this buddy\n", authors.getItemCount()));
for (UT_sint32 i = 0; i < authors.getItemCount(); i++)
{
pp_Author* pAuthor = authors.getNthItem(i);
UT_continue_if_fail(pAuthor);
const gchar* szDescriptor = NULL;
pAuthor->getProperty("abicollab-descriptor", szDescriptor);
if (!szDescriptor)
continue;
if (buddyDescriptor != szDescriptor)
continue;
// yay, we know this author!
iAuthorId = pAuthor->getAuthorInt();
UT_DEBUGMSG(("Found known author with descriptior %s, id %d!\n", buddyDescriptor.utf8_str(), iAuthorId));
break;
}
if (iAuthorId == -1)
{
// we don't know this author yet, create a new author object for him
iAuthorId = pDoc->findFirstFreeAuthorInt();
pp_Author * pA = pDoc->addAuthor(iAuthorId);
PP_AttrProp * pPA = pA->getAttrProp();
pPA->setProperty("abicollab-descriptor", buddyDescriptor.utf8_str());
pDoc->sendAddAuthorCR(pA);
UT_DEBUGMSG(("Added a new author to the documument with descriptor %s, id %d\n", buddyDescriptor.utf8_str(), iAuthorId));
}
// serialize entire document into string
JoinSessionRequestResponseEvent jsre(jse->getSessionId(), iAuthorId);
if (AbiCollabSessionManager::serializeDocument(pDoc, jsre.m_sZABW, false /* no base64 */) == UT_OK)
{
// set more document properties
jsre.m_iRev = pDoc->getCRNumber();
jsre.m_sDocumentId = pDoc->getDocUUIDString();
if (pDoc->getFilename())
jsre.m_sDocumentName = UT_go_basename_from_uri(pDoc->getFilename());
// send to buddy!
send(&jsre, buddy);
// add this buddy to the collaboration session
pSession->addCollaborator(buddy);
}
break;
}
case PCT_JoinSessionRequestResponseEvent:
{
JoinSessionRequestResponseEvent* jsre = static_cast<JoinSessionRequestResponseEvent*>( packet );
PD_Document* pDoc = 0;
if (AbiCollabSessionManager::deserializeDocument(&pDoc, jsre->m_sZABW, false) == UT_OK)
{
if (pDoc)
{
// NOTE: we could adopt the same document name here, but i'd
// rather not at the moment - MARCM
pDoc->forceDirty();
if (jsre->m_sDocumentName.size() > 0)
{
gchar* fname = g_strdup(jsre->m_sDocumentName.utf8_str());
pDoc->setFilename(fname);
}
// The default ownership when joining is FALSE, as that seems
// to make sense for the generic case. The person sharing the
// document by default owns the document (and is thus allowed
// to modify the ACL).
pManager->joinSession(jsre->getSessionId(), pDoc, jsre->m_sDocumentId, jsre->m_iRev, jsre->getAuthorId(), buddy, this, false, NULL);
}
else
{
UT_DEBUGMSG(("AccountHandler::_handlePacket() - deserializing document failed!\n"));
}
}
break;
}
case PCT_GetSessionsEvent:
{
GetSessionsResponseEvent gsre;
const UT_GenericVector<AbiCollab *> sessions = pManager->getSessions();
for (UT_sint32 i = 0; i < sessions.getItemCount(); i++)
{
AbiCollab* pSession = sessions.getNthItem(i);
if (pSession && pSession->isLocallyControlled())
{
// check if the buddy has access to this session
if (!hasAccess(pSession->getAcl(), buddy))
{
UT_DEBUGMSG(("Buddy %s denied access to session %s by ALC\n", buddy->getDescriptor(true).utf8_str(), pSession->getSessionId().utf8_str()));
continue;
}
const PD_Document * pDoc = pSession->getDocument();
UT_continue_if_fail(pDoc);
// determine name
UT_UTF8String documentBaseName;
if (pDoc->getFilename())
documentBaseName = UT_go_basename_from_uri(pDoc->getFilename());
// set session info
gsre.m_Sessions[ pSession->getSessionId() ] = documentBaseName;
}
}
send(&gsre, buddy);
break;
}
case PCT_GetSessionsResponseEvent:
{
GetSessionsResponseEvent* gsre = static_cast<GetSessionsResponseEvent*>( packet );
UT_GenericVector<DocHandle*> vDocHandles;
for (std::map<UT_UTF8String,UT_UTF8String>::iterator it=gsre->m_Sessions.begin(); it!=gsre->m_Sessions.end(); ++it) {
DocHandle* pDocHandle = new DocHandle((*it).first, (*it).second);
vDocHandles.addItem(pDocHandle);
}
pManager->setDocumentHandles(buddy, vDocHandles);
break;
}
default:
{
UT_DEBUGMSG(("Unhandled packet class: 0x%x\n", packet->getClassType()));
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
break;
}
}
}
/*!
* Fill the supplied vector with a list of the blocks whose lines are affected
* by the Frame.
*/
void fp_FrameContainer::getBlocksAroundFrame(UT_GenericVector<fl_BlockLayout *> & vecBlocks)
{
fp_Page * pPage = getPage();
if(pPage == NULL)
{
return;
}
UT_sint32 iColLeader = 0;
fp_Column * pCol = NULL;
fl_BlockLayout * pCurBlock = NULL;
fp_Line * pCurLine = NULL;
fp_Container * pCurCon = NULL;
if(pPage->countColumnLeaders() == 0)
{
UT_sint32 iPage = getPreferedPageNo();
if(iPage >0)
setPreferedPageNo(iPage-1);
return;
}
for(iColLeader = 0; iColLeader < pPage->countColumnLeaders(); iColLeader++)
{
pCol = pPage->getNthColumnLeader(iColLeader);
while(pCol)
{
UT_sint32 i = 0;
UT_sint32 iYCol = pCol->getY(); // Vertical position relative to page.
for(i=0; i< pCol->countCons(); i++)
{
pCurCon = static_cast<fp_Container *>(pCol->getNthCon(i));
if(pCurCon->getContainerType() == FP_CONTAINER_LINE)
{
pCurLine = static_cast<fp_Line *>(pCurCon);
UT_sint32 iYLine = iYCol + pCurLine->getY();
xxx_UT_DEBUGMSG(("iYLine %d FullY %d FullHeight %d \n",iYLine,getFullY(),getFullHeight()));
if((iYLine + pCurLine->getHeight() > getFullY()) && (iYLine < (getFullY() + getFullHeight())))
{
//
// Line overlaps frame in Height. Add it's block to the vector.
//
if(pCurLine->getBlock() != pCurBlock)
{
pCurBlock = pCurLine->getBlock();
vecBlocks.addItem(pCurBlock);
xxx_UT_DEBUGMSG(("Add Block %x to vector \n",pCurBlock));
}
}
}
}
pCol = pCol->getFollower();
}
}
if(vecBlocks.getItemCount() == 0)
{
pCol = pPage->getNthColumnLeader(0);
fp_Container * pCon = pCol->getFirstContainer();
fl_BlockLayout * pB = NULL;
if(pCon && pCon->getContainerType() == FP_CONTAINER_LINE)
{
pB = static_cast<fp_Line *>(pCon)->getBlock();
}
else if(pCon)
{
fl_ContainerLayout * pCL = static_cast<fl_ContainerLayout *>(pCon->getSectionLayout());
pB = pCL->getNextBlockInDocument();
}
if(pB != NULL)
vecBlocks.addItem(pB);
}
}
/*!
* Massage the byte buffer into an array of strings that can be loaded by
* gdk-pixbuf
*/
GdkPixbuf * IE_ImpGraphic_GdkPixbuf::_loadXPM(UT_ByteBuf * pBB)
{
GdkPixbuf * pixbuf = NULL;
const char * pBC = reinterpret_cast<const char *>(pBB->getPointer(0));
UT_GenericVector<char*> vecStr;
UT_sint32 k =0;
UT_sint32 iBase =0;
//
// Find dimension line to start with.
//
UT_sint32 length = static_cast<UT_sint32>(pBB->getLength());
for(k =0; (*(pBC+k) != '"') &&( k < length); k++)
;
if(k >= length)
{
return NULL;
}
k++;
iBase = k;
for(; (*(pBC+k) != '"') && (k < length); k++)
;
if(k >= length)
{
return NULL;
}
char * sz = NULL;
UT_sint32 kLen = k-iBase+1;
sz = static_cast<char *>(UT_calloc(kLen,sizeof(char)));
UT_sint32 i =0;
for(i=0; i< (kLen -1); i++)
{
*(sz+i) = *(pBC+iBase+i);
}
*(sz+i) = 0;
vecStr.addItem(sz);
//
// Now loop through all the lines until we get to "}" outside the
// '"'
while((*(pBC+k) != '}') && (k < length) )
{
k++;
//
// Load a single string of data into our vector.
//
if(*(pBC+k) =='"')
{
//
// Start of a line
//
k++;
iBase = k;
for(; (*(pBC+k) != '"') && (k < length); k++)
{
}
if(k >= length)
{
return NULL;
}
sz = NULL;
kLen = k-iBase+1;
sz = static_cast<char *>(UT_calloc(kLen,sizeof(char)));
for(i=0; i<(kLen -1); i++)
{
*(sz+i) = *(pBC+iBase+i);
}
*(sz +i) = 0;
vecStr.addItem(sz);
}
}
if(k >= length)
{
for(i=0; i< vecStr.getItemCount(); i++)
{
char * psz = vecStr.getNthItem(i);
FREEP(psz);
}
return NULL;
}
const char ** pszStr = static_cast<const char **>(UT_calloc(vecStr.getItemCount(),sizeof(char *)));
for(i=0; i< vecStr.getItemCount(); i++)
pszStr[i] = vecStr.getNthItem(i);
pixbuf = gdk_pixbuf_new_from_xpm_data(pszStr);
DELETEP(pszStr);
return pixbuf;
}
bool pt_PieceTable::_realInsertObject(PT_DocPosition dpos,
PTObjectType pto,
const gchar ** attributes,
const gchar ** properties )
{
// dpos == 1 seems to be generally bad. - plam
// I'm curious about how often it happens. Please mail me if it does!
UT_ASSERT_HARMLESS(dpos > 1);
// TODO currently we force the caller to pass in the attr/prop.
// TODO this is probably a good thing for Images, but might be
// TODO bogus for things like Fields.
UT_return_val_if_fail (m_pts==PTS_Editing,false);
// store the attributes and properties and get an index to them.
UT_UTF8String sProps;
UT_sint32 i = 0;
sProps.clear();
if(properties != NULL)
{
for(i=0;(properties[i] != NULL);i+=2)
{
UT_DEBUGMSG(("Object: szProps = |%s| \n",properties[i]));
sProps +=properties[i];
sProps += ":";
sProps += properties[i+1];
if(properties[i+2] != NULL)
{
sProps += ";";
}
}
}
UT_GenericVector<const gchar*> Atts;
Atts.clear();
if(attributes)
{
for(i=0; attributes[i] != 0; i++)
{
Atts.addItem(attributes[i]);
}
}
if(sProps.size() > 0)
{
Atts.addItem("props");
Atts.addItem(sProps.utf8_str());
}
PT_AttrPropIndex indexAP;
if (!m_varset.storeAP(&Atts,&indexAP))
return false;
// get the fragment at the given document position.
pf_Frag * pf = NULL;
PT_BlockOffset fragOffset = 0;
bool bFound = getFragFromPosition(dpos,&pf,&fragOffset);
UT_return_val_if_fail (bFound,false);
pf_Frag_Strux * pfs = NULL;
bool bFoundStrux = _getStruxFromFrag(pf,&pfs);
UT_return_val_if_fail (bFoundStrux,false);
if(isEndFootnote((pf_Frag *) pfs))
{
bFoundStrux = _getStruxFromFragSkip((pf_Frag *)pfs,&pfs);
}
UT_return_val_if_fail (bFoundStrux,false);
PT_BlockOffset blockOffset = _computeBlockOffset(pfs,pf) + fragOffset;
pf_Frag_Object * pfo = NULL;
if (!_insertObject(pf,fragOffset,pto,indexAP,pfo))
return false;
// create a change record, add it to the history, and notify
// anyone listening.
PX_ChangeRecord_Object * pcr
= new PX_ChangeRecord_Object(PX_ChangeRecord::PXT_InsertObject,
dpos,indexAP,pfo->getXID(),pto,blockOffset,
pfo->getField(),reinterpret_cast<PL_ObjectHandle>(pfo));
UT_return_val_if_fail (pcr,false);
m_history.addChangeRecord(pcr);
m_pDocument->notifyListeners(pfs,pcr);
return true;
}
