/*!
* Assuming a string of standard abiword properties eg. "fred:nerk; table-width:1.0in; table-height:10.in"
* Add aother propety string, updating previously defined properties with
* values in the new string.
*/
void UT_UTF8String_addPropertyString(UT_UTF8String & sPropertyString, const UT_UTF8String & sNewProp)
{
UT_sint32 iSize = static_cast<UT_sint32>(sNewProp.size());
UT_sint32 iBase =0;
UT_UTF8String sProp;
UT_UTF8String sVal;
UT_UTF8String sSubStr;
const char * szWork = NULL;
const char * szLoc = NULL;
while(iBase < iSize)
{
bool bBreakAtEnd = false;
sSubStr = sNewProp.substr(iBase, iSize-iBase);
szWork = sSubStr.utf8_str();
szLoc = strstr(szWork,":");
UT_sint32 iextra = 0;
if(szLoc)
{
UT_sint32 k = iBase;
while(*sNewProp.substr(k,k).utf8_str() == ' ')
{
k++;
iextra++;
}
sProp = sNewProp.substr(k,szLoc - szWork-iextra);
}
else
{
break;
}
iBase += szLoc-szWork+1;
sSubStr = sNewProp.substr(iBase, iSize-iBase);
szWork = sSubStr.utf8_str();
szLoc = strstr(szWork,";");
if(szLoc)
{
sVal = sNewProp.substr(iBase,szLoc - szWork);
iBase += szLoc-szWork+1;
}
else
{
sVal = sNewProp.substr(iBase,iSize-iBase);
bBreakAtEnd = true;
}
if((sProp.size()>0) && (sVal.size() >0))
{
UT_UTF8String_setProperty(sPropertyString,sProp,sVal);
}
else
{
break;
}
if(bBreakAtEnd)
{
break;
}
}
}
void AP_UnixDialog_Stylist::setStyleInGUI(void)
{
UT_sint32 row,col;
UT_UTF8String sCurStyle = *getCurStyle();
if((getStyleTree() == NULL) || (sCurStyle.size() == 0))
updateDialog();
if(m_wStyleList == NULL)
return;
if(isStyleTreeChanged())
_fillTree();
getStyleTree()->findStyle(sCurStyle,row,col);
UT_DEBUGMSG(("After findStyle row %d col %d col \n",row,col));
UT_UTF8String sPathFull = UT_UTF8String_sprintf("%d:%d",row,col);
UT_UTF8String sPathRow = UT_UTF8String_sprintf("%d",row);
UT_DEBUGMSG(("Full Path string is %s \n",sPathFull.utf8_str()));
GtkTreePath * gPathRow = gtk_tree_path_new_from_string (sPathRow.utf8_str());
GtkTreePath * gPathFull = gtk_tree_path_new_from_string (sPathFull.utf8_str());
gtk_tree_view_expand_row( GTK_TREE_VIEW(m_wStyleList),gPathRow,TRUE);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(m_wStyleList),gPathFull,NULL,TRUE,0.5,0.5);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(m_wStyleList),gPathFull,NULL,TRUE);
setStyleChanged(false);
gtk_tree_path_free(gPathRow);
gtk_tree_path_free(gPathFull);
}
void AP_Win32Dialog_Stylist::setStyleInGUI(void)
{
UT_sint32 row,col;
UT_UTF8String sCurStyle = *getCurStyle();
if((getStyleTree() == NULL) || (sCurStyle.size() == 0))
updateDialog();
if(isStyleTreeChanged())
_fillTree();
getStyleTree()->findStyle(sCurStyle,row,col);
UT_DEBUGMSG(("After findStyle row %d col %d col \n",row,col));
UT_UTF8String sPathFull = UT_UTF8String_sprintf("%d:%d",row,col);
UT_UTF8String sPathRow = UT_UTF8String_sprintf("%d",row);
UT_DEBUGMSG(("Full Path string is %s \n",sPathFull.utf8_str()));
HWND hTree = GetDlgItem(m_hWnd, AP_RID_DIALOG_STYLIST_TREE_STYLIST);
HTREEITEM hitem = NULL;
hitem = TreeView_GetRoot(hTree);
UT_sint32 i;
// Go through each row until we've found ours
for (i = 0; i < row; i++)
hitem = TreeView_GetNextItem(hTree, hitem, TVGN_NEXT);
hitem = TreeView_GetNextItem(hTree, hitem, TVGN_CHILD);
for (i = 0; i < col; i++)
hitem = TreeView_GetNextItem(hTree, hitem, TVGN_NEXT);
TreeView_SelectItem(hTree, hitem);
setStyleChanged(false);
}
/*!
* Assuming a string of standard abiword properties eg. "fred:nerk; table-width:1.0in; table-height:10.in"
* Add the property sProp with value sVal to the string of properties. If the property is already present, replace the
* old value with the new value.
*/
void UT_UTF8String_setProperty(UT_UTF8String & sPropertyString, const UT_UTF8String & sProp, const UT_UTF8String & sVal)
{
//
// Remove the old value if it exists and tack the new property on the end.
//
UT_UTF8String_removeProperty(sPropertyString, sProp);
if(sPropertyString.size() > 0)
{
sPropertyString += "; ";
}
sPropertyString += sProp;
sPropertyString += ":";
sPropertyString += sVal;
}
bool GR_MathManager::convert(UT_uint32 iConType, UT_ByteBuf & From, UT_ByteBuf & To)
{
XAP_App * pApp = XAP_App::getApp();
XAP_Frame * pFrame = pApp->getLastFocussedFrame();
if (iConType != 0)
{
return false;
}
/* add a pair of enclosing brackets \[ \] */
UT_UTF8String sLatex;
UT_UCS4_mbtowc myWC;
sLatex += "\\[";
sLatex.appendBuf(From, myWC);
sLatex += "\\]";
char * mathml = itex2MML_parse(sLatex.utf8_str(), sLatex.size());
if (!mathml)
{
pFrame->showMessageBox("itex2MML failed to convert the LaTeX equation into MathML, sorry!\n", // TODO: fix message
XAP_Dialog_MessageBox::b_O,
XAP_Dialog_MessageBox::a_OK);
return false;
}
UT_UTF8String sMathML(mathml);
itex2MML_free_string(mathml);
if (sMathML.size() == 0)
{
UT_UTF8String sErrMessage = "itex2MML conversion from LaTex equation resulted in zero-length MathML!\n"; // TODO: fix message
//sErrMessage += sLatex;
sErrMessage += "\n";
// sErrMessage += FullLine;
pFrame->showMessageBox(sErrMessage.utf8_str(),
XAP_Dialog_MessageBox::b_O,
XAP_Dialog_MessageBox::a_OK);
return false;
}
UT_DEBUGMSG(("Input MathML %s \n", sMathML.utf8_str()));
return EntityTable().convert(sMathML.utf8_str(), sMathML.size(), To);
}
bool ODe_MetaDataWriter::writeMetaData(PD_Document* pDoc, GsfOutfile* oo) {
GsfOutput* meta = gsf_outfile_new_child (oo, "meta.xml", FALSE);
static const UT_UTF8String preamble =
UT_UTF8String("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<office:document-meta"
" xmlns:office=\"urn:oasis:names:tc:opendocument:xmlns:office:1.0\""
" xmlns:xlink=\"http://www.w3.org/1999/xlink\""
" xmlns:dc=\"http://purl.org/dc/elements/1.1/\""
" xmlns:meta=\"urn:oasis:names:tc:opendocument:xmlns:meta:1.0\""
" xmlns:ooo=\"http://openoffice.org/2004/office\""
" office:version=\"1.1\">\n"
"<office:meta>\n"
"<meta:generator>AbiWord/") + PACKAGE_VERSION + " (" + PLATFORM + ", " + TOOLKIT + ")</meta:generator>\n";
static const char * const postamble [] = {
"</office:meta>\n",
"</office:document-meta>\n"
};
ODe_writeUTF8String(meta, preamble);
UT_UTF8String meta_val, val;
#define WRITE_METADATA_ELEMENT(abiwordKey, odElementName) if (pDoc->getMetaDataProp(abiwordKey, meta_val) && meta_val.size()) { \
meta_val.escapeXML(); \
val = UT_UTF8String_sprintf("<%s>%s</%s>\n", odElementName, meta_val.utf8_str(), odElementName); \
ODe_writeUTF8String (meta, val); \
}
WRITE_METADATA_ELEMENT(PD_META_KEY_TITLE, "dc:title");
WRITE_METADATA_ELEMENT(PD_META_KEY_DESCRIPTION, "dc:description");
WRITE_METADATA_ELEMENT(PD_META_KEY_SUBJECT, "dc:subject");
//Each keyword needs to be exported individually:
UT_UTF8String keywords;
if (pDoc->getMetaDataProp (PD_META_KEY_KEYWORDS, keywords) && keywords.size())
{
UT_UTF8String buf = "";
UT_UCS4String keyword = keywords.utf8_str();
for(UT_uint32 i = 0;i < keyword.length(); i++)
{
if(keyword[i] != ' ')
{
buf += keyword[i];
}
else
{
if(buf.empty()) //only blank space encountered
continue;
buf.escapeXML();
val = UT_UTF8String_sprintf("<meta:keyword>%s</meta:keyword>\n", buf.utf8_str());
ODe_writeUTF8String(meta, val);
buf.clear();
}
}
if(buf.length()) //there may only be one keyword (i.e. no spaces encountered)
{
buf.escapeXML();
val = UT_UTF8String_sprintf("<meta:keyword>%s</meta:keyword>\n", buf.utf8_str());
ODe_writeUTF8String(meta, val);
}
}
// Should have a PD_META_KEY_INITIAL_CREATOR macro for this one, but only
// if it gets implemented on the document properties dialog.
WRITE_METADATA_ELEMENT("meta:initial-creator", "meta:initial-creator");
WRITE_METADATA_ELEMENT(PD_META_KEY_CREATOR, "dc:creator");
WRITE_METADATA_ELEMENT("meta:printed-by", "meta:printed-by");
// ATTENTION: I'm assuming that dc.date is used by AbiWord as
// the document creation date & time.
WRITE_METADATA_ELEMENT(PD_META_KEY_DATE, "meta:creation-date");
// Note that, for the OpenDocument standard, dc.date
// is the last modification date & time.
WRITE_METADATA_ELEMENT(PD_META_KEY_DATE_LAST_CHANGED, "dc:date");
WRITE_METADATA_ELEMENT("meta:print-date", "meta:print-date");
WRITE_METADATA_ELEMENT(PD_META_KEY_LANGUAGE, "dc:language");
#undef WRITE_METADATA_ELEMENT
ODe_writeToStream(meta, postamble, G_N_ELEMENTS(postamble));
ODe_gsf_output_close(meta);
return true;
}
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;
}
bool operator!=(const UT_UTF8String& s1, const std::string &s2)
{
if (s1.size() != s2.size()) return true;
return s1.utf8_str() != s2;
}
bool operator==(const UT_UTF8String& s1, const UT_UTF8String& s2)
{
if (s1.size() != s2.size()) return false;
return strcmp(s1.utf8_str(), s2.utf8_str()) == 0;
}
/*!
* Assuming a string of standard abiword properties eg. "fred:nerk; table-width:1.0in; table-height:10.in"
* Remove the property sProp and it's value from the string of properties.
*/
void UT_UTF8String_removeProperty(UT_UTF8String & sPropertyString, const UT_UTF8String & sProp)
{
//
// Warning, warning!!! lots of brutal const casts and assignments into
// strings to handle utf8 encoding.
//
UT_UTF8String sWork ( sProp );
sWork += ":";
const char * szWork = sWork.utf8_str();
const char * szProps = sPropertyString.utf8_str();
const char * szLoc = strstr(szProps,szWork);
if(szLoc == NULL)
{
//
// Not here, do nothing
return ;
}
//
// Found it, Get left part.
//
UT_sint32 locLeft = static_cast<UT_sint32>(reinterpret_cast<size_t>(szLoc) - reinterpret_cast<size_t>(szProps));
UT_UTF8String sLeft;
if(locLeft == 0)
{
sLeft.clear();
}
else
{
UT_UTF8String sTmp = sPropertyString;
char * szTmp = const_cast<char *>(sTmp.utf8_str());
szTmp[locLeft] = 0;
sLeft = szTmp;
}
char * szLeft = const_cast<char *>(sLeft.utf8_str());
locLeft--;
if(locLeft > 0)
{
//
// If this element is the last item in the properties there is no "; ".
//
// Remove trailing ';' and ' '
//
while(locLeft >= 0 && (szLeft[locLeft] == ';' || szLeft[locLeft] == ' '))
{
locLeft--;
}
}
UT_UTF8String sNew;
if(locLeft > 0)
{
szLeft[locLeft+1] = 0;
sNew = szLeft;
}
else
{
sNew.clear();
}
//
// Look for ";" to get right part
//
const char * szDelim = strchr(szLoc,';');
if(szDelim == NULL)
{
//
// No properties after this, just assign and return
//
sPropertyString = sNew;
}
else
{
//
// Just slice off the properties and tack them onto the pre-existing sNew
//
while(*szDelim == ';' || *szDelim == ' ')
{
szDelim++;
}
UT_UTF8String sRight = szDelim;
if(sNew.size() > 0)
{
sNew += "; ";
}
sNew += sRight;
sPropertyString = sNew;
}
}
gint XAP_UnixDialog_FileOpenSaveAs::previewPicture (void)
{
UT_ASSERT (m_FC && m_preview);
UT_ASSERT(XAP_App::getApp());
const XAP_StringSet * pSS = m_pApp->getStringSet();
UT_return_val_if_fail( pSS, 0 );
// attach and clear the area immediately
GR_UnixCairoAllocInfo ai(m_preview);
GR_CairoGraphics* pGr =
(GR_CairoGraphics*) XAP_App::getApp()->newGraphics(ai);
const gchar * file_name = gtk_file_chooser_get_uri (m_FC);
GR_Font * fnt = pGr->findFont("Times New Roman",
"normal", "", "normal",
"", "12pt",
pSS->getLanguageName());
pGr->setFont(fnt);
UT_UTF8String str;
pSS->getValueUTF8(XAP_STRING_ID_DLG_IP_No_Picture_Label, str);
int answer = 0;
FG_Graphic * pGraphic = 0;
GR_Image *pImage = NULL;
double scale_factor = 0.0;
UT_sint32 scaled_width,scaled_height;
UT_sint32 iImageWidth,iImageHeight;
{
GR_Painter painter(pGr);
painter.clearArea(0, 0, pGr->tlu(m_preview->allocation.width), pGr->tlu(m_preview->allocation.height));
if (!file_name)
{
painter.drawChars (str.ucs4_str().ucs4_str(), 0, str.size(), pGr->tlu(12), pGr->tlu(static_cast<int>(m_preview->allocation.height / 2)) - pGr->getFontHeight(fnt)/2);
goto Cleanup;
}
// are we dealing with a file or directory here?
struct stat st;
if (!stat (file_name, &st))
{
if (!S_ISREG(st.st_mode))
{
painter.drawChars (str.ucs4_str().ucs4_str(), 0, str.size(), pGr->tlu(12), pGr->tlu(static_cast<int>(m_preview->allocation.height / 2)) - pGr->getFontHeight(fnt)/2);
goto Cleanup;
}
}
GsfInput * input = NULL;
UT_DEBUGMSG(("file_name %s \n",file_name));
input = UT_go_file_open (file_name, NULL);
if (!input)
goto Cleanup;
char Buf[4097] = ""; // 4096+nul ought to be enough
UT_uint32 iNumbytes = UT_MIN(4096, gsf_input_size(input));
gsf_input_read(input, iNumbytes, (guint8 *)(Buf));
Buf[iNumbytes] = '\0';
IEGraphicFileType ief = IE_ImpGraphic::fileTypeForContents(Buf,4096);
if((ief == IEGFT_Unknown) || (ief == IEGFT_Bogus))
{
painter.drawChars (str.ucs4_str().ucs4_str(), 0, str.size(), pGr->tlu(12), pGr->tlu(static_cast<int>(m_preview->allocation.height / 2)) - pGr->getFontHeight(fnt)/2);
g_object_unref (G_OBJECT (input));
goto Cleanup;
}
g_object_unref (G_OBJECT (input));
input = UT_go_file_open (file_name, NULL);
size_t num_bytes = gsf_input_size(input);
UT_Byte * bytes = (UT_Byte *) gsf_input_read(input, num_bytes,NULL );
if(bytes == NULL)
{
painter.drawChars (str.ucs4_str().ucs4_str(), 0, str.size(), pGr->tlu(12), pGr->tlu(static_cast<int>(m_preview->allocation.height / 2)) - pGr->getFontHeight(fnt)/2);
g_object_unref (G_OBJECT (input));
goto Cleanup;
}
UT_ByteBuf * pBB = new UT_ByteBuf();
pBB->append(bytes,num_bytes);
g_object_unref (G_OBJECT (input));
//
// OK load the data into a GdkPixbuf
//
bool bLoadFailed = false;
//
GdkPixbuf * pixbuf = pixbufForByteBuf ( pBB);
delete pBB;
if(pixbuf == NULL)
{
//
// Try a fallback loader here.
//
painter.drawChars (str.ucs4_str().ucs4_str(), 0, str.size(), pGr->tlu(12), pGr->tlu(static_cast<int>(m_preview->allocation.height / 2)) - pGr->getFontHeight(fnt)/2);
bLoadFailed = true;
goto Cleanup;
}
pImage = new GR_UnixImage(NULL,pixbuf);
iImageWidth = gdk_pixbuf_get_width (pixbuf);
iImageHeight = gdk_pixbuf_get_height (pixbuf);
if (m_preview->allocation.width >= iImageWidth && m_preview->allocation.height >= iImageHeight)
scale_factor = 1.0;
else
scale_factor = MIN( static_cast<double>(m_preview->allocation.width)/iImageWidth,
static_cast<double>(m_preview->allocation.height)/iImageHeight);
scaled_width = static_cast<int>(scale_factor * iImageWidth);
scaled_height = static_cast<int>(scale_factor * iImageHeight);
static_cast<GR_UnixImage *>(pImage)->scale(scaled_width,scaled_height);
painter.drawImage(pImage,
pGr->tlu(static_cast<int>((m_preview->allocation.width - scaled_width ) / 2)),
pGr->tlu(static_cast<int>((m_preview->allocation.height - scaled_height) / 2)));
answer = 1;
}
Cleanup:
FREEP(file_name);
DELETEP(pImage);
DELETEP(pGr);
DELETEP(pGraphic);
return answer;
}
bool XAP_UnixDialog_FileOpenSaveAs::_run_gtk_main(XAP_Frame * pFrame,
GtkWidget * filetypes_pulldown)
{
/*
Run the dialog in a loop to catch bad filenames.
The location of this check being in this dialog loop
could be considered temporary. Doing this matches the Windows
common control behavior (where the dialog checks everything
for the programmer), but lacks flexibility for different
uses of this dialog (file export, print export, directory
(not file) selection).
This check might need to be moved into the ap code which calls
this dialog, and certain interfaces exposed so that the
dialog is displayed throughout the verification.
For right now you can signal this check on and off with
bCheckWritePermission.
*/
char * szDialogFilename = NULL; // this is the file name returned from the dialog
char * szFinalPathname = NULL; // this is the file name after suffix addition, if any
char * szFinalPathnameCopy = NULL; // one to mangle when looking for dirs, etc.
char * pLastSlash;
// if m_bSave is not set, we're looking to OPEN a file.
// otherwise we are looking to SAVE a file.
if (!m_bSave)
{
while (1)
{
gtk_main();
if (m_answer == a_CANCEL) // The easy way out
return false;
m_szFinalPathnameCandidate = gtk_file_chooser_get_uri(m_FC);
UT_ASSERT(m_szFinalPathnameCandidate);
return (m_answer == a_OK);
}
}
else
{
while(1)
{
gtk_main();
if (m_answer == a_CANCEL) // The easy way out
return false;
// Give us a filename we can mangle
szDialogFilename = gtk_file_chooser_get_uri(m_FC);
if (!szDialogFilename)
continue;
// We append the suffix of the default type, so the user doesn't
// have to. This is adapted from the Windows front-end code
// (xap_Win32Dlg_FileOpenSaveAs.cpp), since it should act the same.
// If, however, the user doesn't want suffixes, they don't have to have them.
{
//UT_uint32 end = g_strv_length(m_szSuffixes);
UT_sint32 nFileType = XAP_comboBoxGetActiveInt(GTK_COMBO_BOX(filetypes_pulldown));
// set to first item, which should probably be auto detect
// TODO : "probably" isn't very good.
UT_uint32 nIndex = 0;
// the index in the types table will match the index in the suffix
// table. nFileType is the data we are searching for.
if(m_nTypeList != NULL)
{
for (UT_uint32 i = 0; m_nTypeList[i]; i++)
{
if (m_nTypeList[i] == nFileType)
{
nIndex = i;
break;
}
}
}
bool wantSuffix = true;
XAP_Prefs *pPrefs= XAP_App::getApp()->getPrefs();
pPrefs->getPrefsValueBool(static_cast<const gchar *>(XAP_PREF_KEY_UseSuffix), &wantSuffix);
UT_DEBUGMSG(("UseSuffix: %d\n", wantSuffix));
if (nFileType > 0 && getDialogId() != XAP_DIALOG_ID_FILE_SAVE_IMAGE) // 0 means autodetect
{
if (!UT_pathSuffix(szDialogFilename).empty())
{
// warn if we have a suffix that doesn't match the selected file type
IE_ExpSniffer* pSniffer = IE_Exp::snifferForFileType(m_nTypeList[nIndex]);
if (pSniffer && !pSniffer->recognizeSuffix(UT_pathSuffix(szDialogFilename).c_str()))
{
UT_UTF8String msg;
const XAP_StringSet * pSS = m_pApp->getStringSet();
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ExtensionDoesNotMatch, msg);
if (pFrame->showMessageBox(msg.utf8_str(), XAP_Dialog_MessageBox::b_YN, XAP_Dialog_MessageBox::a_NO) != XAP_Dialog_MessageBox::a_YES)
goto ContinueLoop;
}
szFinalPathname = g_strdup(szDialogFilename);
}
else if (wantSuffix)
{
// if the file doesn't have a suffix already, and the file type
// is normal (special types are negative, like auto detect),
// and the user wants extensions, slap a suffix on it.
// add suffix based on selected file type
UT_UTF8String suffix (IE_Exp::preferredSuffixForFileType(m_nTypeList[nIndex]));
UT_uint32 length = strlen(szDialogFilename) + suffix.size() + 1;
szFinalPathname = static_cast<char *>(UT_calloc(length,sizeof(char)));
if (szFinalPathname)
{
char * p = szFinalPathname;
strcpy(p,szDialogFilename);
strcat(p,suffix.utf8_str());
}
}
else
szFinalPathname = g_strdup(szDialogFilename);
}
else
{
// the file type is special (auto detect)
// set to plain name, and let the auto detector in the
// exporter figure it out
szFinalPathname = g_strdup(szDialogFilename);
}
// g_free szDialogFilename since it's been put into szFinalPathname (with
// or without changes) and it's invalid (missing an extension which
// might have been appended)
FREEP(szDialogFilename);
}
szFinalPathnameCopy = g_strdup(szFinalPathname);
if (UT_go_file_exists(szFinalPathnameCopy))
{
// we have an existing file, ask to overwrite
if (_askOverwrite_YesNo(pFrame, szFinalPathname))
{
m_szFinalPathnameCandidate = g_strdup(szFinalPathname);
goto ReturnTrue;
}
goto ContinueLoop;
}
// We have a string that may contain a path, and may have a file
// at the end. First, strip off a file (if it exists), and test
// for a matching directory. We can then proceed with the file
// if another stat of that dir passes.
if (szFinalPathnameCopy && strlen(szFinalPathnameCopy))
pLastSlash = strrchr(szFinalPathnameCopy,'/');
else
pLastSlash = NULL;
if (!pLastSlash)
{
_notifyError_OKOnly(pFrame,XAP_STRING_ID_DLG_InvalidPathname);
goto ContinueLoop;
}
m_szFinalPathnameCandidate = g_strdup(szFinalPathname);
goto ReturnTrue;
// complain about write permission on the directory.
// lop off ugly trailing slash only if we don't have
// the root dir ('/') for a path
if (pLastSlash > szFinalPathnameCopy)
*pLastSlash = 0;
_notifyError_OKOnly(pFrame,XAP_STRING_ID_DLG_NoSaveFile_DirNotWriteable,
szFinalPathname);
ContinueLoop:
FREEP(szFinalPathnameCopy);
}
} /* if m_bSave */
/*NOTREACHED*/
ReturnTrue:
FREEP(szFinalPathnameCopy);
FREEP(szFinalPathname);
return true;
}
void AbiCollabSessionManager::loadProfile()
{
UT_DEBUGMSG(("AbiCollabSessionManager::loadProfile()\n"));
gchar *s = g_build_filename(XAP_App::getApp()->getUserPrivateDirectory(),
"AbiCollab.Profile", (void*)0);
UT_UTF8String profile(s);
FREEP(s);
GsfInput* in = NULL;
char *uri = UT_go_filename_to_uri(profile.utf8_str());
UT_return_if_fail(uri);
in = UT_go_file_open(uri, NULL); // TODO: shouldn't use NULL here, but check for errors
FREEP(uri);
if (!in)
return;
guint8 const* contents = gsf_input_read(in, gsf_input_size(in), NULL);
if (contents)
{
xmlDocPtr reader = xmlReadMemory(reinterpret_cast<const char*>(contents),
strlen(reinterpret_cast<const char*>(contents)), 0, "UTF-8", 0);
if (reader)
{
xmlNode* node = xmlDocGetRootElement(reader);
if (node)
{
if (strcmp(reinterpret_cast<const char*>(node->name), "AbiCollabProfile") == 0)
{
for (xmlNode* accountNode = node->children; accountNode; accountNode = accountNode->next)
{
// TODO: check if this node is really an AccountHandler node
// find the account handler belonging to this type
xmlChar* prop = xmlGetProp(accountNode, BAD_CAST "type");
UT_UTF8String handlerType = reinterpret_cast<char *>(prop);
xmlFree(prop);
std::map<UT_UTF8String, AccountHandlerConstructor>::iterator handler_iter = m_regAccountHandlers.find(handlerType);
if (handler_iter == m_regAccountHandlers.end())
continue; // could happen for example when the sugar backend is found in the profile, which does not have a registered account handler belowing to it for now
AccountHandlerConstructor constructor = handler_iter->second;
AccountHandler* pHandler = constructor();
UT_continue_if_fail(pHandler);
for (xmlNode* accountProp = accountNode->children; accountProp; accountProp = accountProp->next)
{
if (accountProp->type == XML_ELEMENT_NODE)
{
// some node names are pre-defined...
if (strcmp(reinterpret_cast<const char*>(accountProp->name), "buddies") == 0)
{
for (xmlNode* buddyNode = accountProp->children; buddyNode; buddyNode = buddyNode->next)
{
if (buddyNode->type != XML_ELEMENT_NODE)
continue;
UT_continue_if_fail(strcmp(reinterpret_cast<const char*>(buddyNode->name), "buddy") == 0);
UT_continue_if_fail(buddyNode->children);
// read all buddy properties
PropertyMap vBuddyProps;
for (xmlNode* buddyPropertyNode = buddyNode->children; buddyPropertyNode; buddyPropertyNode = buddyPropertyNode->next)
{
UT_continue_if_fail(buddyPropertyNode->type == XML_ELEMENT_NODE);
UT_UTF8String buddyPropValue = reinterpret_cast<const char*>(xmlNodeGetContent(buddyPropertyNode));
UT_continue_if_fail(buddyPropertyNode->name && *buddyPropertyNode->name && buddyPropValue.size() > 0);
vBuddyProps.insert(PropertyMap::value_type(
reinterpret_cast<const char*>(buddyPropertyNode->name),
buddyPropValue.utf8_str())
);
}
// construct the buddy
BuddyPtr pBuddy = pHandler->constructBuddy(vBuddyProps);
if (pBuddy)
{
// add the buddy to the account handler
pHandler->addBuddy(pBuddy);
}
}
}
else
{
// ... the rest are generic properties
UT_UTF8String propValue = reinterpret_cast<const char*>(xmlNodeGetContent(accountProp));
pHandler->addProperty(reinterpret_cast<const char*>(accountProp->name), propValue.utf8_str());
}
}
}
// add the account to the account list if it is not a duplicate
if (addAccount(pHandler))
{
if (pHandler->autoConnect())
pHandler->connect();
}
else
{
_deleteAccount(pHandler);
}
}
}
}
xmlFreeDoc(reader);
}
}
g_object_unref(G_OBJECT(in));
}
void AbiCollabSessionManager::setDocumentHandles(BuddyPtr pBuddy, const UT_GenericVector<DocHandle*>& vDocHandles)
{
UT_DEBUGMSG(("Setting document handles for buddy %s\n", pBuddy->getDescriptor().utf8_str()));
UT_return_if_fail(pBuddy);
// create a copy of the current document handles, which
// we'll use to determine which document handles do not exist anymore
std::vector<DocHandle*> oldDocHandles(pBuddy->getDocHandles());
for (UT_sint32 i = 0; i < vDocHandles.size(); i++)
{
DocHandle* pDocHandle = vDocHandles.getNthItem(i);
UT_continue_if_fail(pDocHandle);
// sanity checking
UT_UTF8String sId = pDocHandle->getSessionId();
UT_continue_if_fail(sId.size() > 0);
// construct a nice document name
UT_UTF8String sDocumentName = pDocHandle->getName();
if (sDocumentName.size() == 0)
{
// this document has no name yet; give it an untitled name
const XAP_StringSet * pSS = XAP_App::getApp()->getStringSet();
std::string sUntitled;
pSS->getValueUTF8(XAP_STRING_ID_UntitledDocument, sUntitled);
UT_UTF8String_sprintf(sDocumentName, sUntitled.c_str(), 0);
// TODO: as should append a number here, but at the moment
// XAP_Frame::m_iUntitled is not accessible from here
}
// check to see if we already have a document handle with this ID
DocHandle* pCurDocHandle = pBuddy->getDocHandle(sId);
if (!pCurDocHandle)
{
// Ok, all set. Get the buddy from the AccountHandler, and assign
// the document handle to the buddy
DocHandle * pNewDocHandle = new DocHandle(sId, sDocumentName);
pBuddy->addDocHandle(pNewDocHandle);
UT_DEBUGMSG(("Added DocHandle (%s) to buddy (%s)\n", sId.utf8_str(), pBuddy->getDescription().utf8_str()));
// signal that a buddy has a new session
AccountBuddyAddDocumentEvent event(pNewDocHandle);
signal(event, pBuddy);
}
else
{
UT_DEBUGMSG(("Found an existing DocHandle (%s) for buddy (%s)\n", sId.utf8_str(), pBuddy->getDescription().utf8_str()));
// we already have a handle for this document, remove it from the old document handles copy
for (std::vector<DocHandle*>::iterator it = oldDocHandles.begin(); it != oldDocHandles.end(); it++)
{
DocHandle* pOldDocHandle = *it;
if (pCurDocHandle == pOldDocHandle)
{
oldDocHandles.erase(it);
break;
}
}
}
}
// every document that is still in the old document handles list does not
// exist anymore, so let's delete it
std::vector<DocHandle*>::iterator it = oldDocHandles.begin();
while (it != oldDocHandles.end())
{
DocHandle* pDocHandle = *it;
UT_continue_if_fail(pDocHandle);
// TODO: when we are a part of this session, then handle that properly
UT_DEBUGMSG(("Purging existing DocHandle (%s) for buddy (%s)\n", pDocHandle->getSessionId().utf8_str(), pBuddy->getDescription().utf8_str()));
UT_UTF8String pDestroyedSessionId = pDocHandle->getSessionId();
pBuddy->destroyDocHandle(pDestroyedSessionId);
CloseSessionEvent event(pDestroyedSessionId);
signal(event, pBuddy);
it = oldDocHandles.erase(it);
}
}