bool IE_Imp_EPUB::pasteFromBuffer(PD_DocumentRange* pDocRange,
const unsigned char* pData, UT_uint32 lenData, const char* /*szEncoding*/)
{
UT_return_val_if_fail(getDoc() == pDocRange->m_pDoc,false);
UT_return_val_if_fail(pDocRange->m_pos1 == pDocRange->m_pos2,false);
PD_Document * newDoc = new PD_Document();
newDoc->createRawDocument();
IE_Imp_EPUB * pEPUBImp = new IE_Imp_EPUB(newDoc);
//
// Turn pData into something that can be imported by the open documenb
// importer.
//
GsfInput * pInStream = gsf_input_memory_new((const guint8 *) pData,
(gsf_off_t) lenData, FALSE);
pEPUBImp->loadFile(newDoc, pInStream);
newDoc->finishRawCreation();
IE_Imp_PasteListener * pPasteListen = new IE_Imp_PasteListener(getDoc(),
pDocRange->m_pos1, newDoc);
newDoc->tellListener(static_cast<PL_Listener *> (pPasteListen));
delete pPasteListen;
delete pEPUBImp;
UNREFP( newDoc);
return true;
}
/*!
* Autoupdater of the dialog.
*/
void AP_Dialog_SplitCells::autoUpdateMC(UT_Worker * pTimer)
{
UT_return_if_fail(pTimer);
// this is a static callback method and does not have a 'this' pointer
AP_Dialog_SplitCells * pDialog = static_cast<AP_Dialog_SplitCells *>(pTimer->getInstanceData());
if (pDialog->m_bDestroy_says_stopupdating != true)
{
FV_View * pView = 0;
PD_Document * pDoc = NULL;
if (XAP_Frame * pFrame = pDialog->getApp()->getLastFocussedFrame())
{
pView = static_cast<FV_View *>(pFrame->getCurrentView());
}
if (pView)
{
pDoc = pView->getDocument();
}
if (!pView || (pDoc && !pDoc->isPieceTableChanging()))
{
pDialog->m_bAutoUpdate_happening_now = true;
pDialog->setAllSensitivities();
pDialog->m_bAutoUpdate_happening_now = false;
}
}
}
bool AP_UnixApp::makePngPreview(const char * pszInFile, const char * pszPNGFile, UT_sint32 iWidth, UT_sint32 iHeight)
{
cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, iWidth, iHeight);
cairo_t *cr = cairo_create (surface);
GR_UnixCairoAllocInfo ai(NULL, false);
GR_CairoGraphics * pG = static_cast<GR_CairoGraphics*>(GR_UnixCairoGraphics::graphicsAllocator(ai));
pG->setCairo(cr);
pG->beginPaint(); // needed to avoid cairo reference loss
UT_Error error = UT_OK;
PD_Document * pNewDoc = new PD_Document();
error = pNewDoc->readFromFile(pszInFile,IEFT_Unknown, NULL);
if (error != UT_OK)
{
return false;
}
AP_Preview_Abi * pPrevAbi = new AP_Preview_Abi(pG,iWidth,iHeight,NULL, PREVIEW_ZOOMED,pNewDoc);
dg_DrawArgs da;
memset(&da, 0, sizeof(da));
da.pG = pG;
GR_Painter * pPaint = new GR_Painter(pG);
pPaint->clearArea(0,0,pG->tlu(iWidth),pG->tlu(iHeight));
pPrevAbi->getView()->draw(0, &da);
pG->endPaint();
cairo_destroy(cr);
DELETEP(pPaint);
cairo_surface_write_to_png(surface, pszPNGFile);
cairo_surface_destroy(surface);
DELETEP(pG);
DELETEP(pPrevAbi); // This deletes pNewDoc
return true;
}
bool AbiCollabSessionManager::_setupFrame(XAP_Frame** pFrame, PD_Document* pDoc)
{
UT_return_val_if_fail(pFrame, false);
if (*pFrame)
{
UT_DEBUGMSG(("Frame is non-NULL, NOT loading document in the frame\n"));
return true;
}
// if the document doesn't belong to a frame already, then create a
// new frame for this session (except when the document in the current
// frame is not dirty, doesn't have a filename yet (which means it
// is a brand new empty document), and isn't being shared at the moment)
XAP_Frame* pCurFrame = XAP_App::getApp()->getLastFocussedFrame();
UT_return_val_if_fail(pCurFrame, false);
bool isNewFrame = false;
PD_Document * pFrameDoc = static_cast<PD_Document *>(pCurFrame->getCurrentDoc());
if (pFrameDoc != pDoc)
{
if (!pFrameDoc || (pFrameDoc->getFilename().empty() && !pFrameDoc->isDirty() && !isInSession(pFrameDoc)))
{
// we can replace the document in this frame safely, as it is
// brand new, and doesn't have any contents yet
}
else
{
// the current frame has already a document loaded, let's create
// a new frame
pCurFrame = XAP_App::getApp()->newFrame();
isNewFrame = true;
}
}
else
{
UT_DEBUGMSG(("This document is already in the current frame; using this frame\n"));
}
UT_return_val_if_fail(pCurFrame, false);
*pFrame = pCurFrame;
// load the document in the frame; this will also delete the old document (or at least, it should)
if (static_cast<PD_Document *>((*pFrame)->getCurrentDoc()) != pDoc)
{
UT_DEBUGMSG(("Loading the document in the frame\n"));
(*pFrame)->loadDocument(pDoc);
}
else
{
UT_DEBUGMSG(("Not loading the document in the frame, as the frame already has it\n"));
}
if (isNewFrame)
(*pFrame)->show();
return true;
}
PD_DocumentRDFHandle
AP_Dialog_RDFEditor::getRDF()
{
FV_View* view = getView();
PD_Document* doc = view->getDocument();
PD_DocumentRDFHandle rdf = doc->getDocumentRDF();
return rdf;
}
bool s_abicollab_authors(AV_View* v, EV_EditMethodCallData* /*d*/)
{
AbiCollabSessionManager* pManager = AbiCollabSessionManager::getManager();
UT_return_val_if_fail(pManager, false);
FV_View * pView = static_cast<FV_View *>(v);
PD_Document * pDoc = pView->getDocument();
bool b = pDoc->isShowAuthors();
pDoc->setShowAuthors(!b);
return true;
}
bool fp_FieldTOCNumRun::calculateValue(void)
{
UT_UCSChar sz_ucs_FieldValue[FPFIELD_MAX_LENGTH + 1];
//
// First Find page number.
//
PL_StruxDocHandle sdh = getBlock()->getStruxDocHandle();
PD_Document * pDoc = getBlock()->getDocument();
PT_DocPosition pos = pDoc->getStruxPosition(sdh)+1;
FL_DocLayout * pLayout = getBlock()->getDocLayout();
fl_BlockLayout * pBlockInDoc = pLayout->findBlockAtPosition(pos);
if(pBlockInDoc == NULL)
{
sz_ucs_FieldValue[0] = static_cast<UT_UCSChar>(' ');
sz_ucs_FieldValue[1] = 0;
return _setValue(sz_ucs_FieldValue);
}
fp_Line * pLine = static_cast<fp_Line *>(pBlockInDoc->getFirstContainer());
if(pLine == NULL)
{
sz_ucs_FieldValue[0] = static_cast<UT_UCSChar>(' ');
sz_ucs_FieldValue[1] = 0;
return _setValue(sz_ucs_FieldValue);
}
fp_Page * pPage = pLine->getPage();
UT_sint32 iPage = pLayout->findPage(pPage);
if( iPage < 0)
{
sz_ucs_FieldValue[0] = static_cast<UT_UCSChar>(' ');
sz_ucs_FieldValue[1] = 0;
return _setValue(sz_ucs_FieldValue);
}
iPage++; // Start from Page 1.
UT_String sVal("");
FootnoteType iType = getBlock()->getTOCNumType();
pLayout->getStringFromFootnoteVal(sVal,iPage,iType);
const char * psz = sVal.c_str();
bool bStop = false;
UT_sint32 i = 0;
sz_ucs_FieldValue[0] = static_cast<UT_UCSChar>(' ');
for(i=1; (i<FPFIELD_MAX_LENGTH) && !bStop; i++)
{
sz_ucs_FieldValue[i] = static_cast<UT_UCSChar>(*psz);
if(*psz == 0)
{
bStop = true;
}
else
{
psz++;
}
}
return _setValue(sz_ucs_FieldValue);
}
PD_RDFModelHandle
AP_Dialog_RDFEditor::getModel()
{
if( m_restrictedModel )
return m_restrictedModel;
FV_View* view = getView();
PD_Document* doc = view->getDocument();
PD_DocumentRDFHandle model = doc->getDocumentRDF();
return model;
}
bool fp_FieldListLabelRun::calculateValue(void)
{
UT_UCSChar sz_ucs_FieldValue[FPFIELD_MAX_LENGTH + 1];
UT_uint32 i = 0;
UT_UCSChar * listlabel = NULL;
if(getBlock()->isContainedByTOC())
{
xxx_UT_DEBUGMSG(("!!!!!!------!!!! ListLabel in TOC!!!! \n"));
//
// First Find the block in the document.
//
pf_Frag_Strux* sdh = getBlock()->getStruxDocHandle();
PD_Document * pDoc = getBlock()->getDocument();
PT_DocPosition pos = pDoc->getStruxPosition(sdh)+1;
FL_DocLayout * pLayout = getBlock()->getDocLayout();
fl_BlockLayout * pBlockInDoc = pLayout->findBlockAtPosition(pos);
if(pBlockInDoc == NULL)
{
sz_ucs_FieldValue[0] = static_cast<UT_UCSChar>(' ');
sz_ucs_FieldValue[1] = 0;
return _setValue(sz_ucs_FieldValue);
}
i = 0;
listlabel = pBlockInDoc->getListLabel();
}
else
{
i = 0;
listlabel = getBlock()->getListLabel();
}
if(listlabel == NULL)
{
sz_ucs_FieldValue[0] = 0;
}
else
{
//
// This code is here because UT_UCS_copy_char is broken
//
i = 0;
UT_uint32 len = UT_MIN( UT_UCS4_strlen(listlabel),FPFIELD_MAX_LENGTH + 1) ;
for(i=0; i<=len;i++)
{
sz_ucs_FieldValue[i] = *listlabel++;
}
// sz_ucs_FieldValue[len] = 0;
// m_sFieldValue[0] = 0; // Force an update!!!
}
return _setValue(sz_ucs_FieldValue);
}
bool AP_Win32App::_cacheClipboardDoc(PD_DocumentRange *pDocRange)
{
UT_return_val_if_fail(m_pClipboard && pDocRange, false);
UT_ByteBuf buf;
UT_Error status;;
UT_Byte b = 0;
IE_Exp_RTF * pExpRtf = new IE_Exp_RTF(pDocRange->m_pDoc);
if (pExpRtf)
{
status = pExpRtf->copyToBuffer(pDocRange,&buf);
if(status != UT_OK)
return false;
buf.append(&b,1); // NULL terminate the string
DELETEP(pExpRtf);
}
else
{
return false;
}
// now create a subdocument ...
PD_Document * pDoc = new PD_Document();
if(!pDoc)
return false;
pDoc->newDocument();
PD_DocumentRange DocRange(pDoc, 2, 2);
IE_Imp * pImp = 0;
IE_Imp::constructImporter(pDoc, IE_Imp::fileTypeForSuffix(".rtf"),&pImp,0);
if(pImp)
{
pImp->pasteFromBuffer(&DocRange,buf.getPointer(0),buf.getLength(),NULL);
delete pImp;
}
else
{
return false;
}
m_pClipboard->setClipboardDoc(pDoc);
return true;
}
//
// AbiMathView_FileInsert
// -------------------
// This is the function that we actually call to insert the MathML.
//
bool
AbiMathView_FileInsert(AV_View* /*v*/, EV_EditMethodCallData* /*d*/)
{
// Get the current view that the user is in.
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
FV_View* pView = static_cast<FV_View*>(pFrame->getCurrentView());
PD_Document * pDoc = static_cast<PD_Document *>(pFrame->getCurrentDoc());
char* pNewFile = NULL;
bool bOK = s_AskForMathMLPathname(pFrame,&pNewFile);
if (!bOK || !pNewFile)
{
UT_DEBUGMSG(("ARRG! bOK = %d pNewFile = %s \n",bOK,pNewFile));
return false;
}
UT_UTF8String sNewFile = pNewFile;
// we own storage for pNewFile and must free it.
FREEP(pNewFile);
UT_DEBUGMSG(("fileInsertMathML: loading [%s]\n",sNewFile.utf8_str()));
IE_Imp_MathML * pImpMathML = new IE_Imp_MathML(pDoc, pMathManager->EntityTable());
UT_Error errorCode = pImpMathML->importFile(sNewFile.utf8_str());
if (errorCode != UT_OK)
{
s_CouldNotLoadFileMessage(pFrame, sNewFile.utf8_str(), errorCode);
DELETEP(pImpMathML);
return false;
}
/* Create the data item */
UT_uint32 uid = pDoc->getUID(UT_UniqueId::Image);
UT_UTF8String sUID;
UT_UTF8String_sprintf(sUID,"%d",uid);
pDoc->createDataItem(sUID.utf8_str(), false, pImpMathML->getByteBuf(),
"application/mathml+xml", NULL);
/* Insert the MathML Object */
PT_DocPosition pos = pView->getPoint();
pView->cmdInsertMathML(sUID.utf8_str(),pos);
DELETEP(pImpMathML);
return true;
}
void fp_FrameContainer::setPreferedPageNo(UT_sint32 i)
{
if(m_iPreferedPageNo == i)
return;
m_iPreferedPageNo = i;
fl_FrameLayout * pFL = static_cast<fl_FrameLayout *>(getSectionLayout());
FL_DocLayout * pDL = pFL->getDocLayout();
if(pDL->isLayoutFilling())
return;
PD_Document * pDoc = pDL->getDocument();
UT_UTF8String sVal;
UT_UTF8String_sprintf(sVal,"%d",i);
const char * attr = PT_PROPS_ATTRIBUTE_NAME;
UT_UTF8String sAttVal = "pref-page:";
sAttVal += sVal.utf8_str();
pDoc->changeStruxAttsNoUpdate(pFL->getStruxDocHandle(),attr,sAttVal.utf8_str());
}
AbiCollab* AbiCollabSessionManager::getSessionFromDocumentId(const UT_UTF8String& sDocumentId)
{
AbiCollab * pCollab = NULL;
UT_sint32 i = 0;
for(i = 0; i < m_vecSessions.getItemCount(); i++)
{
pCollab = m_vecSessions.getNthItem(i);
if (pCollab)
{
PD_Document* pDoc = pCollab->getDocument();
if (strcmp(pDoc->getDocUUIDString(), sDocumentId.utf8_str()) == 0)
{
return pCollab;
}
}
}
return NULL;
}
bool AP_UnixToolbar_StyleCombo::populate(void)
{
// clear anything that's already there
m_vecContents.clear();
// populate the vector
#if 1
// HACK: for now, just hardwire it
// NB if you change the case of the labels, it will stop working
// unless you also change all the places where the style appears!
m_vecContents.addItem("Normal");
m_vecContents.addItem("Heading 1");
m_vecContents.addItem("Heading 2");
m_vecContents.addItem("Heading 3");
m_vecContents.addItem("Plain Text");
m_vecContents.addItem("Block Text");
#else
AD_Document * pAD_Doc = m_pFrame->getCurrentDoc();
if(!pAD_Doc)
{
return false;
}
PD_Document *pDocument = static_cast<PD_Document *>(pAD_Doc);
// TODO: need a view/doc pointer to get this right
// ALSO: will need to repopulate as new styles added
// HYP: only call this method from shared code?
const char * szName;
const PD_Style * pStyle;
for (UT_uint32 k=0; (pDocument->enumStyles(k,&szName,&pStyle)); k++)
{
if (pStyle && pStyle->isDisplayed()) {
m_vecContents.addItem(szName);
}
}
#endif
return true;
}
bool IE_Imp_OpenDocument::pasteFromBuffer(PD_DocumentRange * pDocRange,
const unsigned char * pData,
UT_uint32 lenData,
const char * /*szEncoding*/)
{
UT_return_val_if_fail(getDoc() == pDocRange->m_pDoc,false);
UT_return_val_if_fail(pDocRange->m_pos1 == pDocRange->m_pos2,false);
PD_Document * newDoc = new PD_Document();
newDoc->createRawDocument();
IE_Imp_OpenDocument * pODImp = new IE_Imp_OpenDocument(newDoc);
//
// Turn pData into something that can be imported by the open documenb
// importer.
//
GsfInput * pInStream = gsf_input_memory_new((const guint8 *) pData,
(gsf_off_t) lenData,
FALSE);
pODImp->loadFile(newDoc, pInStream);
// pInStream deleted after load.
newDoc->finishRawCreation();
// Handle RDF for the newdoc
{
PD_DocumentRDFHandle rdf = newDoc->getDocumentRDF();
rdf->dumpModel("about to broadcast...");
PD_DocumentRDFMutationHandle m = getDoc()->getDocumentRDF()->createMutation();
m->add( rdf );
m->commit();
}
//
// OK Broadcast from the just filled source document into our current
// doc via the paste listener
//
IE_Imp_PasteListener * pPasteListen = new IE_Imp_PasteListener(getDoc(),pDocRange->m_pos1,newDoc);
newDoc->tellListener(static_cast<PL_Listener *>(pPasteListen));
delete pPasteListen;
delete pODImp;
UNREFP( newDoc);
return true;
}
bool s_MIF_Listener::populate(fl_ContainerLayout* /*sfh*/,
const PX_ChangeRecord * pcr)
{
switch (pcr->getType())
{
case PX_ChangeRecord::PXT_InsertSpan:
{
const PX_ChangeRecord_Span * pcrs = static_cast<const PX_ChangeRecord_Span *> (pcr);
PT_BufIndex bi = pcrs->getBufIndex();
_outputData(m_pDocument->getPointer(bi),pcrs->getLength());
return true;
}
case PX_ChangeRecord::PXT_InsertObject:
{
#if 0
// TODO decide how to indicate objects in MIF output.
const PX_ChangeRecord_Object * pcro = static_cast<const PX_ChangeRecord_Object *> (pcr);
PT_AttrPropIndex api = pcr->getIndexAP();
switch (pcro->getObjectType())
{
case PTO_Image:
return true;
case PTO_Field:
return true;
// todo: support these
case PTO_Hyperlink:
case PTO_Bookmark:
return true;
default:
UT_ASSERT(0);
return false;
}
#else
return true;
#endif
}
case PX_ChangeRecord::PXT_InsertFmtMark:
return true;
default:
UT_ASSERT(0);
return false;
}
}
bool AP_UnixApp::makePngPreview(const char * pszInFile, const char * pszPNGFile, UT_sint32 iWidth, UT_sint32 iHeight)
{
GdkPixmap* pPixmap = gdk_pixmap_new(NULL,iWidth,iHeight,24);
GR_UnixPixmapAllocInfo ai(pPixmap);
GR_UnixPangoPixmapGraphics * pG = (GR_UnixPangoPixmapGraphics*) GR_UnixPangoPixmapGraphics::graphicsAllocator(ai);
UT_Error error = UT_OK;
PD_Document * pNewDoc = new PD_Document();
error = pNewDoc->readFromFile(pszInFile,IEFT_Unknown, NULL);
if (error != UT_OK)
{
return false;
}
AP_Preview_Abi * pPrevAbi = new AP_Preview_Abi(pG,iWidth,iHeight,NULL, PREVIEW_ZOOMED,pNewDoc);
dg_DrawArgs da;
memset(&da, 0, sizeof(da));
da.pG = pG;
GR_Painter * pPaint = new GR_Painter(pG);
pPaint->clearArea(0,0,pG->tlu(iWidth),pG->tlu(iHeight));
pPrevAbi->getView()->draw(0, &da);
UT_Rect r;
r.left = 0;
r.top = 0;
r.width = pG->tlu(iWidth);
r.height = pG->tlu(iHeight);
GR_Image * pImage = pPaint->genImageFromRectangle(r);
DELETEP(pPaint);
static_cast<GR_UnixImage *>(pImage)->saveToPNG( pszPNGFile);
DELETEP(pImage);
DELETEP(pG);
DELETEP(pPrevAbi); // This deletes pNewDoc
return true;
}
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;
}
}
}
bool fp_FieldTOCNumRun::calculateValue(void)
{
UT_UCSChar sz_ucs_FieldValue[FPFIELD_MAX_LENGTH + 1];
//
// First Find page number.
//
pf_Frag_Strux* sdh = getBlock()->getStruxDocHandle();
PD_Document * pDoc = getBlock()->getDocument();
PT_DocPosition pos = pDoc->getStruxPosition(sdh)+1;
FL_DocLayout * pLayout = getBlock()->getDocLayout();
fl_BlockLayout * pBlockInDoc = pLayout->findBlockAtPosition(pos);
if(pBlockInDoc == NULL)
{
sz_ucs_FieldValue[0] = static_cast<UT_UCSChar>(' ');
sz_ucs_FieldValue[1] = 0;
return _setValue(sz_ucs_FieldValue);
}
fp_Line * pLine = static_cast<fp_Line *>(pBlockInDoc->getFirstContainer());
UT_sint32 kk = 0;
bool b_goodLine = false;
while (pLine && !b_goodLine)
{
for (kk = 0; kk < pLine->getNumRunsInLine(); kk++)
{
if(pLine->getRunFromIndex(kk)->getType() == FPRUN_TEXT)
{
b_goodLine = true;
break;
}
}
if (!b_goodLine)
{
pLine = static_cast<fp_Line *>(pLine->getNext());
}
}
if(pLine == NULL)
{
sz_ucs_FieldValue[0] = static_cast<UT_UCSChar>(' ');
sz_ucs_FieldValue[1] = 0;
return _setValue(sz_ucs_FieldValue);
}
fp_Page * pPage = pLine->getPage();
UT_sint32 iPage = pPage->getFieldPageNumber();
bool b_hasSetFieldPageNumber = false;
if(iPage < 0)
{
pPage->resetFieldPageNumber();
iPage = pPage->getFieldPageNumber();
b_hasSetFieldPageNumber = true;
if (iPage < 0)
{
sz_ucs_FieldValue[0] = static_cast<UT_UCSChar>(' ');
sz_ucs_FieldValue[1] = 0;
return _setValue(sz_ucs_FieldValue);
}
}
UT_String sVal("");
FootnoteType iType = getBlock()->getTOCNumType();
pLayout->getStringFromFootnoteVal(sVal,iPage,iType);
const char * psz = sVal.c_str();
if (b_hasSetFieldPageNumber)
{
// We need to set the field page number value to -1 so that we
// recalculate the page number next time we enter this function
pPage->setFieldPageNumber(-1);
}
bool bStop = false;
UT_sint32 i = 0;
sz_ucs_FieldValue[0] = static_cast<UT_UCSChar>(' ');
for(i=1; (i<FPFIELD_MAX_LENGTH) && !bStop; i++)
{
sz_ucs_FieldValue[i] = static_cast<UT_UCSChar>(*psz);
if(*psz == 0)
{
bStop = true;
}
else
{
psz++;
}
}
return _setValue(sz_ucs_FieldValue);
}
bool fp_FieldTableSumCols::calculateValue(void)
{
FV_View * pView = _getView();
pf_Frag_Strux* tableSDH= NULL;
UT_sint32 numRows =0;
UT_sint32 numCols = 0;
bUseCurrency = false;
cCurrency = '$';
pf_Frag_Strux* sdh = getBlock()->getStruxDocHandle();
PD_Document * pDoc = getBlock()->getDocument();
if(pDoc->isPieceTableChanging())
{
return false;
}
if(getLine() == NULL)
{
return false;
}
fp_Container * pCol = getLine()->getColumn();
if(pCol == NULL)
{
return false;
}
fp_ShadowContainer * pShad =NULL;
fl_HdrFtrShadow * pShadL = NULL;
if(pCol->getContainerType() == FP_CONTAINER_COLUMN_SHADOW)
{
pShad = static_cast<fp_ShadowContainer *>(pCol);
pShadL = pShad->getShadow();
}
PT_DocPosition pos = pDoc->getStruxPosition(sdh)+1;
pDoc->getStruxOfTypeFromPosition(pos,PTX_SectionTable,&tableSDH);
pDoc-> getRowsColsFromTableSDH(tableSDH, pView->isShowRevisions(), pView->getRevisionLevel(), &numRows, &numCols);
UT_UTF8String sValF;
if(!pView->isInTable(pos))
{
sValF = "???";
return _setValue(sValF.ucs4_str().ucs4_str());
}
fl_CellLayout * pCell = NULL;
UT_sint32 myLeft,myRight,myTop,myBot;
pView->getCellParams(pos,&myLeft,&myRight,&myTop,&myBot);
UT_sint32 col = 0;
UT_sint32 row = myTop;
UT_sint32 lastCol = -1;
double dSum = 0.0;
for(col = 0; col < numCols; col++)
{
pf_Frag_Strux* sdhCell = pDoc->getCellSDHFromRowCol(tableSDH,true,99999,row,col);
UT_sint32 i = getBlock()->getDocLayout()->getLID();
fl_ContainerLayout* fmtCell = pDoc->getNthFmtHandle(sdhCell,i);
pCell = static_cast<fl_CellLayout *>(fmtCell);
if(pCell->getLeftAttach() == lastCol)
{
continue;
}
if((pCell->getTopAttach() == myTop) && (pCell->getLeftAttach() == myLeft))
{
continue;
}
UT_GrowBuf grText;
pCell->appendTextToBuf(grText);
if(grText.getLength() == 0)
{
fl_ContainerLayout * pC = pCell->getFirstLayout();
while(pC)
{
if(pC->getContainerType() == FL_CONTAINER_BLOCK)
{
fl_BlockLayout * pBL = static_cast<fl_BlockLayout *>(pC);
if(pShadL)
{
pBL = static_cast<fl_BlockLayout *>(pShadL->findMatchingContainer(pBL));
}
if(pBL == NULL)
{
continue;
}
fp_Run * pRun = pBL->getFirstRun();
while(pRun)
{
if(pRun->getType() == FPRUN_FIELD)
{
fp_FieldRun * pFRun = static_cast<fp_FieldRun *>(pRun);
const UT_UCS4Char * szVal = pFRun->getValue();
sValF.clear();
sValF.appendUCS4(szVal);
dSum += dGetVal(sValF.utf8_str());
pRun = NULL;
pC = NULL;
break;
}
pRun = pRun->getNextRun();
}
}
if(pC)
{
pC = pC->getNext();
}
}
}
else
{
sValF.clear();
sValF.appendUCS4(reinterpret_cast<const UT_UCS4Char *>(grText.getPointer(0)),grText.getLength());
dSum += dGetVal(sValF.utf8_str());
}
lastCol = col;
}
sFormatDouble(sValF,dSum);
return _setValue(sValF.ucs4_str().ucs4_str());
}
bool AP_UnixToolbar_StyleCombo::repopulate(void)
{
// repopulate the vector from the current document
// If ithere is one present
AD_Document * pAD_Doc = m_pFrame->getCurrentDoc();
if(!pAD_Doc)
{
return false;
}
PD_Document *pDocument = static_cast<PD_Document *>(pAD_Doc);
GR_GraphicsFactory * pGF = XAP_App::getApp()->getGraphicsFactory();
if(!pGF)
{
return false;
}
// clear anything that's already there
m_vecContents.clear();
freeStyles();
// defaults for style combo
if (m_pDefaultDesc == NULL)
{
// for now this is hardcoded
m_pDefaultDesc = pango_font_description_new ();
pango_font_description_set_family (m_pDefaultDesc, "Times");
pango_font_description_set_size (m_pDefaultDesc, 12 * PANGO_SCALE);
}
const char * szName;
const PD_Style * pStyle;
GSList *list = NULL;
for (UT_uint32 k=0; (pDocument->enumStyles(k,&szName,&pStyle)); k++)
{
if (!pStyle) {
UT_DEBUGMSG(("no style instance for '%s'\n", szName));
}
if (!pStyle->isDisplayed() &&
!(dynamic_cast<const PD_BuiltinStyle *>(pStyle) && pStyle->isList() && pStyle->isUsed())) {
continue;
}
list = g_slist_prepend (list, (char *)szName);
/* wysiwyg styles are disabled for now
PangoFontDescription *desc = pango_font_description_copy (m_pDefaultDesc);
getPangoAttrs(pStyle, desc);
m_mapStyles.insert(szName, desc);
*/
}
// Ok, it's a bit hackish to put them in a list for sorting first
// but somehow the vector's qsort totally failed for me
if (list)
{
list = g_slist_sort(list, (GCompareFunc)sort_cb);
do
{
m_vecContents.addItem((const char *)list->data);
} while (NULL != (list = g_slist_next(list)));
g_slist_free(list);
}
return true;
}
/*!
\param doc - the document which we want to iterate
\param dpos - document position we want to start from
*/
PD_DocIterator::PD_DocIterator(const PD_Document &doc, PT_DocPosition dpos)
: m_pt(*doc.getPieceTable()), m_pos(dpos), m_max_pos(0xffffffff), m_frag(NULL), m_status(UTIter_OK)
{
// find the frag at requested postion
_findFrag();
}
/*!
* This method copies the selection defined by pDocRange to ODT format
* placed in the ByteBuf bufODT
*/
UT_Error IE_Exp_OpenDocument::copyToBuffer(PD_DocumentRange * pDocRange,UT_ByteBuf * bufODT)
{
//
// First export selected range to a tempory document
//
PD_Document * outDoc = new PD_Document();
outDoc->createRawDocument();
IE_Exp_DocRangeListener * pRangeListener = new IE_Exp_DocRangeListener(pDocRange,outDoc);
UT_DEBUGMSG(("DocumentRange low %d High %d \n",pDocRange->m_pos1,pDocRange->m_pos2));
PL_ListenerCoupleCloser* pCloser = new PL_ListenerCoupleCloser();
pDocRange->m_pDoc->tellListenerSubset(pRangeListener,pDocRange,pCloser);
if( pCloser)
delete pCloser;
//
// Grab the RDF triples while we are copying...
//
if( PD_DocumentRDFHandle outrdf = outDoc->getDocumentRDF() )
{
std::set< std::string > xmlids;
PD_DocumentRDFHandle inrdf = pDocRange->m_pDoc->getDocumentRDF();
inrdf->addRelevantIDsForRange( xmlids, pDocRange );
if( !xmlids.empty() )
{
UT_DEBUGMSG(("MIQ: ODF export creating restricted RDF model xmlids.sz:%ld \n",(long)xmlids.size()));
PD_RDFModelHandle subm = inrdf->createRestrictedModelForXMLIDs( xmlids );
PD_DocumentRDFMutationHandle m = outrdf->createMutation();
m->add( subm );
m->commit();
subm->dumpModel("copied rdf triples subm");
outrdf->dumpModel("copied rdf triples result");
}
// PD_DocumentRDFMutationHandle m = outrdf->createMutation();
// m->add( PD_URI("http://www.example.com/foo"),
// PD_URI("http://www.example.com/bar"),
// PD_Literal("copyToBuffer path") );
// m->commit();
}
outDoc->finishRawCreation();
//
// OK now we have a complete and valid document containing our selected
// content. We export this to an in memory GSF buffer
//
IE_Exp * pNewExp = NULL;
char *szTempFileName = NULL;
GError *err = NULL;
g_file_open_tmp ("XXXXXX", &szTempFileName, &err);
GsfOutput * outBuf = gsf_output_stdio_new (szTempFileName,&err);
IEFileType ftODT = IE_Exp::fileTypeForMimetype("application/vnd.oasis.opendocument.text");
UT_Error aerr = IE_Exp::constructExporter(outDoc,outBuf,
ftODT,&pNewExp);
if(pNewExp == NULL)
{
return aerr;
}
aerr = pNewExp->writeFile(szTempFileName);
if(aerr != UT_OK)
{
delete pNewExp;
delete pRangeListener;
UNREFP( outDoc);
g_remove(szTempFileName);
g_free (szTempFileName);
return aerr;
}
//
// File is closed at the end of the export. Open it again.
//
GsfInput * fData = gsf_input_stdio_new(szTempFileName,&err);
UT_DebugOnly<UT_sint32> siz = gsf_input_size(fData);
const UT_Byte * pData = gsf_input_read(fData,gsf_input_size(fData),NULL);
UT_DEBUGMSG(("Writing %d bytes to clipboard \n", (UT_sint32)siz));
bufODT->append( pData, gsf_input_size(fData));
delete pNewExp;
delete pRangeListener;
UNREFP( outDoc);
g_remove(szTempFileName);
g_free (szTempFileName);
return aerr;
}
/*!
* Return the nested List level of this structure.
*/
UT_sint32 fl_ContainerLayout::getLevelInList(void)
{
fl_BlockLayout * pBList = NULL;
if(getContainerType() == FL_CONTAINER_BLOCK)
{
pBList = static_cast<fl_BlockLayout * >(this);
}
else
{
pBList = getPrevBlockInDocument();
}
UT_sint32 iLevel = 0;
bool bLoop = true;
while(pBList && bLoop)
{
while(pBList && !pBList->isListItem())
{
pBList = pBList->getPrevBlockInDocument();
}
if(pBList == NULL)
{
bLoop = false;
break;
}
const PP_AttrProp * pAP = NULL;
pBList->getAP(pAP);
const gchar * szLid=NULL;
UT_uint32 id=0;
if (!pAP || !pAP->getAttribute(PT_LISTID_ATTRIBUTE_NAME, szLid))
szLid = NULL;
if (szLid)
{
id = atoi(szLid);
}
else
{
id = 0;
}
if(id == 0)
{
bLoop = false;
break;
}
PD_Document * pDoc = getDocLayout()->getDocument();
fl_AutoNum * pAuto = pDoc->getListByID( id);
if(pAuto->getLastItem() == pBList->getStruxDocHandle())
{
if(pAuto->getLastItem() == getStruxDocHandle())
{
iLevel = pAuto->getLevel();
bLoop = false;
break;
}
iLevel = pAuto->getLevel() -1;
if(iLevel < 0)
{
iLevel = 0;
}
}
else
{
if(pBList == this)
{
iLevel = pAuto->getLevel();
}
else
{
iLevel = pAuto->getLevel() + 1;
}
}
bLoop = false;
break;
}
return iLevel;
}
void AP_Dialog_FormatFrame::setCurFrameProps(void)
{
XAP_Frame * frame = m_pApp->getLastFocussedFrame();
if (!frame) {
if (m_bSensitive) {
m_bSensitive = false;
setAllSensitivities();
}
return;
}
FV_View * pView = static_cast<FV_View *>(frame->getCurrentView());
if (!pView) {
if (m_bSensitive) {
m_bSensitive = false;
setAllSensitivities();
}
return;
}
PT_DocPosition pos = pView->getPoint();
if (/* m_bSettingsChanged || */ m_iOldPos == pos) {
// comparing the actual cell pos would be even better; but who cares :)
return;
}
m_iOldPos = pos;
if (!pView->isInFrame(pos)) {
if (m_bSensitive) {
m_bSensitive = false;
setAllSensitivities();
}
return;
}
m_bLineToggled = false;
m_borderLineStyleRight = LS_NORMAL;
m_borderLineStyleLeft = LS_NORMAL;
m_borderLineStyleTop = LS_NORMAL;
m_borderLineStyleBottom = LS_NORMAL;
UT_RGBColor black(0,0,0);
UT_RGBColor white(255,255,255);
m_borderColor = black;
m_borderColorRight = black;
m_borderColorLeft = black;
m_borderColorTop = black;
m_borderColorBottom = black;
m_borderThicknessRight = 1.0f;
m_borderThicknessLeft = 1.0f;
m_borderThicknessTop = 1.0f;
m_borderThicknessBottom = 1.0f;
m_sBorderThickness = "1.00pt",
m_sBorderThicknessRight = "1.00pt";
m_sBorderThicknessLeft = "1.00pt";
m_sBorderThicknessTop = "1.00pt";
m_sBorderThicknessBottom = "1.00pt";
m_backgroundColor = white;
m_bSetWrapping = false;
m_iFramePositionTo = FL_FRAME_POSITIONED_TO_BLOCK;
PD_Document * pDoc = pView->getDocument();
PL_StruxDocHandle sdh;
m_bSensitive = false;
if (pDoc->getStruxOfTypeFromPosition(pos, PTX_SectionFrame, &sdh))
if (PT_AttrPropIndex api = pDoc->getAPIFromSDH(sdh)) {
const PP_AttrProp * pAP = 0;
if (pDoc->getAttrProp(api, &pAP))
if (pAP) {
m_bSensitive = true;
#define REPLACE_CELL_PROPERTY(X) \
do { \
const gchar * prop = 0; \
if (pAP->getProperty(X, prop)) \
m_vecProps.addOrReplaceProp(X, prop); \
else \
m_vecProps.removeProp(X); \
} while (0)
REPLACE_CELL_PROPERTY("right-style");
REPLACE_CELL_PROPERTY("left-style");
REPLACE_CELL_PROPERTY("top-style");
REPLACE_CELL_PROPERTY("bot-style");
REPLACE_CELL_PROPERTY("right-thickness");
REPLACE_CELL_PROPERTY("left-thickness");
REPLACE_CELL_PROPERTY("top-thickness");
REPLACE_CELL_PROPERTY("bot-thickness");
REPLACE_CELL_PROPERTY("right-color");
REPLACE_CELL_PROPERTY("left-color");
REPLACE_CELL_PROPERTY("top-color");
REPLACE_CELL_PROPERTY("bot-color");
REPLACE_CELL_PROPERTY("background-color");
REPLACE_CELL_PROPERTY("wrap-mode");
REPLACE_CELL_PROPERTY("position-to");
}
}
if (!m_bSensitive) {
setAllSensitivities();
return;
}
if(pView->isImageAtStrux(m_iOldPos,PTX_SectionFrame))
{
if(true /* pView->isInFrame(pView->getPoint()) */)
{
fl_BlockLayout * pBL = pView->getCurrentBlock();
fl_FrameLayout * pFrame = static_cast<fl_FrameLayout *>(pBL->myContainingLayout());
if(pFrame->getContainerType() != FL_CONTAINER_FRAME)
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_sImagePath.clear();
}
else
{
FG_Graphic * pFG = FG_GraphicRaster::createFromStrux(pFrame);
if(pFG)
{
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_sImagePath.clear();
m_pGraphic = pFG;
m_sImagePath = pFG->getDataId();
GR_Graphics * pG = m_pFormatFramePreview->getGraphics();
m_pImage = _makeImageForRaster(m_sImagePath, pG, m_pGraphic);
}
}
}
else
{
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_sImagePath.clear();
}
}
else
{
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_sImagePath.clear();
}
UT_String bstmp = UT_String_sprintf("%d", FS_FILL);
m_vecProps.addOrReplaceProp("bg-style", bstmp.c_str()); // FIXME ??
const gchar * pszStyle = 0;
m_vecProps.getProp("background-color", pszStyle);
if (pszStyle) {
m_backgroundColor.setColor(pszStyle);
}
/* update border properties
*/
long linestyle;
pszStyle = 0;
m_vecProps.getProp("right-style", pszStyle);
if (pszStyle) {
linestyle = LS_NORMAL;
sscanf(pszStyle, "%ld", &linestyle);
m_borderLineStyleRight = linestyle;
}
pszStyle = 0;
m_vecProps.getProp("left-style", pszStyle);
if (pszStyle) {
linestyle = LS_NORMAL;
sscanf(pszStyle, "%ld", &linestyle);
m_borderLineStyleLeft = linestyle;
}
pszStyle = 0;
m_vecProps.getProp("top-style", pszStyle);
if (pszStyle) {
linestyle = LS_NORMAL;
sscanf(pszStyle, "%ld", &linestyle);
m_borderLineStyleTop = linestyle;
}
pszStyle = 0;
m_vecProps.getProp("bot-style", pszStyle);
if (pszStyle) {
linestyle = LS_NORMAL;
sscanf(pszStyle, "%ld", &linestyle);
m_borderLineStyleBottom = linestyle;
}
pszStyle = 0;
m_vecProps.getProp("right-color", pszStyle);
if (pszStyle) {
m_borderColorRight.setColor(pszStyle);
}
pszStyle = 0;
m_vecProps.getProp("left-color", pszStyle);
if (pszStyle) {
m_borderColorLeft.setColor(pszStyle);
}
pszStyle = 0;
m_vecProps.getProp("top-color", pszStyle);
if (pszStyle) {
m_borderColorTop.setColor(pszStyle);
}
pszStyle = 0;
m_vecProps.getProp("bot-color", pszStyle);
if (pszStyle) {
m_borderColorBottom.setColor(pszStyle);
}
UT_UTF8String thickness;
pszStyle = 0;
m_vecProps.getProp("right-thickness", pszStyle);
if (pszStyle) {
thickness = pszStyle;
setBorderThicknessRight(thickness);
}
pszStyle = 0;
m_vecProps.getProp("left-thickness", pszStyle);
if (pszStyle) {
thickness = pszStyle;
setBorderThicknessLeft(thickness);
}
pszStyle = 0;
m_vecProps.getProp("top-thickness", pszStyle);
if (pszStyle) {
thickness = pszStyle;
setBorderThicknessTop(thickness);
}
pszStyle = 0;
m_vecProps.getProp("bot-thickness", pszStyle);
if (pszStyle) {
thickness = pszStyle;
setBorderThicknessBottom(thickness);
}
/* update wrap properties
*/
pszStyle = 0;
m_vecProps.getProp("wrap-mode", pszStyle);
if (pszStyle) {
if (strcmp (pszStyle, "wrapped-both") == 0) {
m_bSetWrapping = true;
}
}
/* update position properties
*/
pszStyle = 0;
m_vecProps.getProp("position-to", pszStyle);
if (pszStyle) {
if (strcmp (pszStyle, "block-above-text") == 0) {
m_iFramePositionTo = FL_FRAME_POSITIONED_TO_BLOCK;
}
else if (strcmp (pszStyle, "column-above-text") == 0) {
m_iFramePositionTo = FL_FRAME_POSITIONED_TO_COLUMN;
}
else if (strcmp (pszStyle, "page-above-text") == 0) {
m_iFramePositionTo = FL_FRAME_POSITIONED_TO_PAGE;
}
}
/* draw the preview with the changed properties
*/
if(m_pFormatFramePreview) {
m_pFormatFramePreview->draw();
}
m_bSettingsChanged = false;
setActiveFrame(frame); // this is just to trigger the subclass to update the dialog
}
AP_App::AP_App (HINSTANCE hInstance, const char * szAppName)
: XAP_App_BaseClass ( hInstance, szAppName )
#else
AP_App::AP_App (const char * szAppName)
: XAP_App_BaseClass ( szAppName )
#endif
{
}
AP_App::~AP_App ()
{
}
/*!
* Open windows requested on commandline.
*
* \return False if an unknown command line option was used, true
* otherwise.
*/
bool AP_App::openCmdLineFiles(const AP_Args * args)
{
int kWindowsOpened = 0;
const char *file = NULL;
if (AP_Args::m_sFiles == NULL) {
// no files to open, this is ok
XAP_Frame * pFrame = newFrame();
pFrame->loadDocument((const char *)NULL, IEFT_Unknown);
return true;
}
int i = 0;
while ((file = AP_Args::m_sFiles[i++]) != NULL) {
char * uri = NULL;
uri = UT_go_shell_arg_to_uri (file);
XAP_Frame * pFrame = newFrame();
UT_Error error = pFrame->loadDocument (uri, IEFT_Unknown, true);
g_free (uri);
if (UT_IS_IE_SUCCESS(error))
{
kWindowsOpened++;
if (error == UT_IE_TRY_RECOVER) {
pFrame->showMessageBox(AP_STRING_ID_MSG_OpenRecovered,
XAP_Dialog_MessageBox::b_O,
XAP_Dialog_MessageBox::a_OK);
}
}
else
{
// TODO we crash if we just delete this without putting something
// TODO in it, so let's go ahead and open an untitled document
// TODO for now. this would cause us to get 2 untitled documents
// TODO if the user gave us 2 bogus pathnames....
// Because of the incremental loader, we should not crash anymore;
// I've got other things to do now though.
kWindowsOpened++;
pFrame->loadDocument((const char *)NULL, IEFT_Unknown);
pFrame->raise();
errorMsgBadFile (pFrame, file, error);
}
if (args->m_sMerge) {
PD_Document * pDoc = static_cast<PD_Document*>(pFrame->getCurrentDoc());
pDoc->setMailMergeLink(args->m_sMerge);
}
}
if (kWindowsOpened == 0)
{
// no documents specified or openable, open an untitled one
XAP_Frame * pFrame = newFrame();
pFrame->loadDocument((const char *)NULL, IEFT_Unknown);
if (args->m_sMerge) {
PD_Document * pDoc = static_cast<PD_Document*>(pFrame->getCurrentDoc());
pDoc->setMailMergeLink(args->m_sMerge);
}
}
return true;
}
UT_Error IE_Imp_EPUB::readStructure()
{
getDoc()->createRawDocument();
getDoc()->finishRawCreation();
for (std::vector<std::string>::iterator i = m_spine.begin(); i
!= m_spine.end(); i++)
{
std::map<std::string, std::string>::iterator iter =
m_manifestItems.find(*i);
if (iter == m_manifestItems.end())
{
UT_DEBUGMSG(("Manifest item with id %s not found\n", (*i).c_str()));
return UT_ERROR;
}
std::string itemPath = m_tmpDir + G_DIR_SEPARATOR_S + (iter->second);
PT_DocPosition posEnd = 0;
getDoc()->getBounds(true, posEnd);
if (i != m_spine.begin())
{
getDoc()->insertStrux(posEnd, PTX_Section, NULL, NULL);
getDoc()->insertStrux(posEnd+1, PTX_Block, NULL, NULL);
posEnd+=2;
}
GsfInput* itemInput = UT_go_file_open(itemPath.c_str(), NULL);
if (itemInput == NULL)
{
UT_DEBUGMSG(("Can`t open item for reading\n"));
return UT_ERROR;
}
PD_Document *currentDoc = new PD_Document();
currentDoc->createRawDocument();
const char *suffix = strchr(itemPath.c_str(), '.');
XAP_App::getApp()->getPrefs()->setIgnoreNextRecent();
if (currentDoc->importFile(itemPath.c_str(),
IE_Imp::fileTypeForSuffix(suffix), true, false, NULL) != UT_OK)
{
UT_DEBUGMSG(("Failed to import file %s\n", itemPath.c_str()));
return UT_ERROR;
}
currentDoc->finishRawCreation();
// const gchar * attributes[3] = {
// "listid",
// "0",
// 0
// };
// PT_DocPosition pos;
// currentDoc->getBounds(true, pos);
// currentDoc->insertStrux(pos, PTX_Block, attributes, NULL, NULL);
IE_Imp_PasteListener * pPasteListener = new IE_Imp_PasteListener(
getDoc(), posEnd, currentDoc);
currentDoc->tellListener(static_cast<PL_Listener *> (pPasteListener));
DELETEP(pPasteListener);
UNREFP(currentDoc);
g_object_unref(G_OBJECT(itemInput));
}
return UT_OK;
}