UT_Error OXML_Element_Math::addToPT(PD_Document * pDocument)
{
UT_uint32 id;
id = pDocument->getUID(UT_UniqueId::Math);
std::string mID = UT_std_string_sprintf("MathLatex%d", id);
std::string lID = UT_std_string_sprintf("LatexMath%d", id);
UT_ByteBuf mathBuf;
UT_ByteBuf latexBuf;
mathBuf.ins(0,reinterpret_cast<const UT_Byte *>(m_MathML.c_str()),static_cast<UT_uint32>(m_MathML.length()));
UT_UTF8String sMathml; // TO DO : use std::string after enabling it in ie_math_convert
UT_UTF8String sLatex,sitex;
sMathml.assign(m_MathML.c_str());
pDocument->createDataItem(mID.c_str(),false,&mathBuf, "", NULL);
if(convertMathMLtoLaTeX(sMathml, sLatex) && convertLaTeXtoEqn(sLatex,sitex))
{
// Conversion of MathML to LaTeX and the Equation Form suceeds
latexBuf.ins(0,reinterpret_cast<const UT_Byte *>(sitex.utf8_str()),static_cast<UT_uint32>(sitex.size()));
pDocument->createDataItem(lID.c_str(), false, &latexBuf, "", NULL);
}
const gchar *atts[5] = { NULL, NULL, NULL, NULL, NULL };
atts[0] = PT_IMAGE_DATAID;
atts[1] = static_cast<const gchar *>(mID.c_str());
atts[2] = static_cast<const gchar *>("latexid");
atts[3] = static_cast<const gchar *>(lID.c_str());
if(!pDocument->appendObject(PTO_Math, atts))
return UT_ERROR;
return UT_OK;
}
void IE_Imp_WordPerfect::openFootnote(const librevenge::RVNGPropertyList & /*propList*/)
{
if (m_bHdrFtrOpenCount) return; // HACK
if (!m_bInSection)
{
X_CheckDocumentError(appendStrux(PTX_Section, PP_NOPROPS));
X_CheckDocumentError(appendStrux(PTX_Block,PP_NOPROPS));
m_bInSection = true;
}
std::string footnoteId = UT_std_string_sprintf("%i", UT_rand());
PP_PropertyVector propsArray = {
"type", "footnote_ref",
"footnote-id", footnoteId
};
X_CheckDocumentError(appendObject(PTO_Field, propsArray));
const PP_PropertyVector attribs = {
"footnote-id", footnoteId
};
X_CheckDocumentError(appendStrux(PTX_SectionFootnote, attribs));
X_CheckDocumentError(appendStrux(PTX_Block, PP_NOPROPS));
m_bRequireBlock = false;
// just change the type.
propsArray[1] = "footnote_anchor";
X_CheckDocumentError(appendObject(PTO_Field, propsArray));
}
UT_Error IE_Exp_EPUB::EPUB2_writeStructure()
{
m_oebpsDir = m_baseTempDir + G_DIR_SEPARATOR_S;
m_oebpsDir += "OEBPS";
UT_go_directory_create(m_oebpsDir.c_str(), NULL);
std::string indexPath = m_oebpsDir + G_DIR_SEPARATOR_S;
indexPath += "index.xhtml";
// Exporting document to XHTML using HTML export plugin
// We need to setup options for HTML exporter according to current settings of EPUB exporter
std::string htmlProps =
UT_std_string_sprintf("embed-css:no;html4:no;use-awml:no;declare-xml:yes;mathml-render-png:%s;split-document:%s;add-identifiers:yes;",
m_exp_opt.bRenderMathMLToPNG ? "yes" : "no",
m_exp_opt.bSplitDocument ? "yes" : "no");
m_pHmtlExporter = new IE_Exp_HTML(getDoc());
m_pHmtlExporter->suppressDialog(true);
m_pHmtlExporter->setProps(htmlProps.c_str());
m_pHmtlExporter->writeFile(indexPath.c_str());
return UT_OK;
}
/**
* Ensure that the manifest:file-entry XML elements exist for all the parent
* directories for path. If such an element already has been written (according to
* pathsAlreadyWritten) then it will not be done again.
*/
void ODe_ManifestWriter::ensureDirectoryManifest( PD_Document* pDoc,
GsfOutput* manifest,
const std::string& path,
std::set< std::string >& pathsAlreadyWritten )
{
std::vector<std::string> directories;
boost::split(directories, path, boost::is_any_of("/"));
if( !directories.empty() )
{
directories.pop_back();
}
std::string runningPath;
for( std::vector<std::string>::iterator iter = directories.begin();
iter != directories.end(); ++iter )
{
runningPath = runningPath + *iter + "/";
if( !pathsAlreadyWritten.count( runningPath ) )
{
pathsAlreadyWritten.insert( runningPath );
std::string name = UT_std_string_sprintf(
" <manifest:file-entry manifest:media-type=\"\" manifest:full-path=\"%s\"/>\n",
runningPath.c_str() );
ODe_gsf_output_write(manifest, name.size(),
reinterpret_cast<const guint8 *>(name.c_str()));
}
}
}
/** set the widget value as float */
void XAP_UnixWidget::setValueFloat(float val)
{
if (GTK_IS_ENTRY(m_widget)) {
std::string str = UT_std_string_sprintf("%f", val);
gtk_entry_set_text(GTK_ENTRY(m_widget), str.c_str());
}
}
/** set the widget int value */
void XAP_UnixWidget::setValueInt(int val)
{
if (GTK_IS_TOGGLE_BUTTON(m_widget)) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_widget), (val?TRUE:FALSE));
}
else if (GTK_IS_LABEL(m_widget)) {
std::string str = UT_std_string_sprintf("%d",val);
gtk_label_set_text(GTK_LABEL(m_widget), str.c_str());
}
else if (GTK_IS_ENTRY(m_widget)) {
std::string str = UT_std_string_sprintf("%d", val);
gtk_entry_set_text(GTK_ENTRY(m_widget), str.c_str());
}
else {
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
}
GR_Font* GR_Graphics::findFont(const char* pszFontFamily,
const char* pszFontStyle,
const char* pszFontVariant,
const char* pszFontWeight,
const char* pszFontStretch,
const char* pszFontSize,
const char* pszLang)
{
GR_Font * pFont = NULL;
// NOTE: we currently favor a readable hash key to make debugging easier
// TODO: speed things up with a smaller key (the three AP pointers?)
std::string key = UT_std_string_sprintf("%s;%s;%s;%s;%s;%s",pszFontFamily,
pszFontStyle, pszFontVariant,
pszFontWeight, pszFontStretch,
pszFontSize);
FontCache::const_iterator iter = m_hashFontCache.find(key);
if (iter == m_hashFontCache.end())
{
// TODO -- note that we currently assume font-family to be a single name,
// TODO -- not a list. This is broken.
pFont = _findFont(pszFontFamily, pszFontStyle,
pszFontVariant,pszFontWeight,
pszFontStretch, pszFontSize,
pszLang);
UT_ASSERT(pFont);
xxx_UT_DEBUGMSG(("Insert font %x in gr_Graphics cache \n",pFont));
// add it to the cache
if(pFont)
m_hashFontCache.insert(std::make_pair(key, pFont));
}
else
{
pFont = iter->second;
}
return pFont;
}
/** set the widget label */
void XAP_UnixWidget::setLabel(const UT_UTF8String &val)
{
if (GTK_IS_BUTTON(m_widget)) {
gtk_button_set_label(GTK_BUTTON(m_widget), val.utf8_str());
}
else if (GTK_IS_LABEL(m_widget)) {
if(!gtk_label_get_use_markup(GTK_LABEL(m_widget))) {
gtk_label_set_text(GTK_LABEL(m_widget), val.utf8_str());
}
else {
std::string markup = UT_std_string_sprintf(m_data.c_str(),
val.utf8_str());
gtk_label_set_label(GTK_LABEL(m_widget), markup.c_str());
}
}
else if (GTK_IS_WINDOW(m_widget)) {
gtk_window_set_title(GTK_WINDOW(m_widget), val.utf8_str());
}
else {
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
}
/*!
* Add the page attributes to the documents
*
* Set all page (section) attributes, and do an appendStrux(PTX_Section,...)
* These settings are global for the whole document: Psion documents
* contain only one single section.
*/
UT_Error IE_Imp_Psion::applyPageAttributes(const psiconv_page_layout_section layout,
bool &with_header, bool &with_footer)
{
UT_return_val_if_fail(layout != NULL, true /* perhaps should be false, but we want loading to proceed */);
UT_UTF8String props,buffer;
// Determine whether we have a header and a footer. We can't append them
// here, because they have to come after the main section (or AbiWord will
// become very confused).
with_header = layout->header && layout->header->text &&
layout->header->text->paragraphs &&
psiconv_list_length(layout->header->text->paragraphs);
with_footer = layout->footer && layout->footer->text &&
layout->footer->text->paragraphs &&
psiconv_list_length(layout->footer->text->paragraphs);
const PP_PropertyVector propsArray = {
// Page width
"width", UT_std_string_sprintf("%6.3f", layout->page_width),
// Page height
"height", UT_std_string_sprintf("%6.3f", layout->page_width),
// Units of width/height
"units", "cm",
// Orientation
"orientation", layout->landscape ? "landscape" : "portrait",
// Page type (we should check for common ones here!)
"pagetype", "Custom"
};
if (!(getDoc()->setPageSizeFromFile(propsArray)))
return UT_IE_IMPORTERROR;
// First page number not yet implemented
// On first page not yet implemented
// left margin
UT_UTF8String_sprintf(buffer,"page-margin-left:%6.3fcm",layout->left_margin);
props += buffer;
// right margin
UT_UTF8String_sprintf(buffer,"; page-margin-right:%6.3fcm",layout->right_margin);
props += buffer;
// top margin
UT_UTF8String_sprintf(buffer,"; page-margin-top:%6.3fcm",layout->top_margin);
props += buffer;
// bottom margin
UT_UTF8String_sprintf(buffer,"; page-margin-bottom:%6.3fcm",layout->bottom_margin);
props += buffer;
// header distance
UT_UTF8String_sprintf(buffer,"; page-margin-header:%6.3fcm",layout->header_dist);
props += buffer;
// footer distance
UT_UTF8String_sprintf(buffer,"; page-margin-footer:%6.3fcm",layout->footer_dist);
props += buffer;
// Now actually append the properties in a PTX_Section strux to the document
UT_DEBUGMSG(("PSION: Page: %s\n",props.utf8_str()));
PP_PropertyVector propsArray2 = {
"props", props.utf8_str()
};
if (with_header) {
propsArray2.push_back("header");
propsArray2.push_back("1");
}
if (with_footer) {
propsArray2.push_back("footer");
propsArray2.push_back("2");
}
if (!(appendStrux(PTX_Section,propsArray2))) {
return UT_IE_IMPORTERROR;
}
return UT_OK;
}
UT_Error IE_Exp_EPUB::EPUB3_writeNavigation()
{
GsfOutput* nav = gsf_outfile_new_child(GSF_OUTFILE(m_oebps), "toc.xhtml",
FALSE);
if (nav == NULL)
{
UT_DEBUGMSG(("Can`t create toc.xhtml file\n"));
return UT_ERROR;
}
GsfXMLOut* navXHTML = gsf_xml_out_new(nav);
gsf_xml_out_start_element(navXHTML, "html");
gsf_xml_out_add_cstr(navXHTML, "xmlns", XHTML_NS);
gsf_xml_out_add_cstr(navXHTML, "xmlns:epub", OPS201_NAMESPACE);
gsf_xml_out_add_cstr(navXHTML, "profile", EPUB3_CONTENT_PROFILE);
gsf_xml_out_start_element(navXHTML, "head");
gsf_xml_out_start_element(navXHTML, "title");
gsf_xml_out_add_cstr(navXHTML, NULL, "Table of Contents");
gsf_xml_out_end_element(navXHTML);
gsf_xml_out_end_element(navXHTML);
gsf_xml_out_start_element(navXHTML, "body");
gsf_xml_out_start_element(navXHTML, "section");
gsf_xml_out_add_cstr(navXHTML, "class", "frontmatter TableOfContents");
gsf_xml_out_start_element(navXHTML, "header");
gsf_xml_out_start_element(navXHTML, "h1");
gsf_xml_out_add_cstr(navXHTML, NULL, "Contents");
gsf_xml_out_end_element(navXHTML);
gsf_xml_out_end_element(navXHTML);
gsf_xml_out_start_element(navXHTML, "nav");
gsf_xml_out_add_cstr(navXHTML, "epub:type", "toc");
gsf_xml_out_add_cstr(navXHTML, "id", "toc");
if (m_pHmtlExporter->getNavigationHelper()->hasTOC())
{
int lastItemLevel;
int curItemLevel = 0;
std::vector<int> tagLevels;
int tocNum = 0;
bool newList = true;
for (int currentItem = 0;
currentItem < m_pHmtlExporter->getNavigationHelper()->getNumTOCEntries();
currentItem++)
{
lastItemLevel = curItemLevel;
UT_UTF8String itemStr = m_pHmtlExporter->getNavigationHelper()
->getNthTOCEntry(currentItem, &curItemLevel);
PT_DocPosition itemPos;
m_pHmtlExporter->getNavigationHelper()->getNthTOCEntryPos(currentItem, itemPos);
std::string itemFilename;
if (m_exp_opt.bSplitDocument)
{
itemFilename = m_pHmtlExporter->getNavigationHelper()
->getFilenameByPosition(itemPos).utf8_str();
if ((itemFilename == "") || itemFilename.length() == 0)
{
itemFilename = "index.xhtml";
} else
{
itemFilename += ".xhtml";
}
} else
{
itemFilename = "index.xhtml";
}
if (std::find(m_opsId.begin(), m_opsId.end(),
escapeForId(itemFilename)) == m_opsId.end())
{
m_opsId.push_back(escapeForId(itemFilename));
tocNum = 0;
}
UT_DEBUGMSG(("Item filename %s at pos %d\n",
itemFilename.c_str(),itemPos));
if ((lastItemLevel >= curItemLevel) && (currentItem != 0))
{
while ((tagLevels.size() > 0)
&& (tagLevels.back() >= curItemLevel))
{
if (tagLevels.back() == curItemLevel)
{
gsf_xml_out_end_element(navXHTML);
} else
{
closeNTags(navXHTML, 2);
}
tagLevels.pop_back();
}
} else
if ((lastItemLevel < curItemLevel) || newList)
{
gsf_xml_out_start_element(navXHTML, "ol");
newList = false;
}
std::string navClass = UT_std_string_sprintf("h%d", curItemLevel);
std::string navId = UT_std_string_sprintf("AbiTOC%d",
tocNum);
std::string navSrc = std::string(itemFilename.c_str()) + "#" + navId;
gsf_xml_out_start_element(navXHTML, "li");
gsf_xml_out_add_cstr(navXHTML, "class", navClass.c_str());
gsf_xml_out_add_cstr(navXHTML, "id", navId.c_str());
gsf_xml_out_start_element(navXHTML, "a");
gsf_xml_out_add_cstr(navXHTML, "href", navSrc.c_str());
gsf_xml_out_add_cstr(navXHTML, NULL, itemStr.utf8_str());
gsf_xml_out_end_element(navXHTML);
// gsf_xml_out_end_element(navXHTML);
tagLevels.push_back(curItemLevel);
tocNum++;
}
closeNTags(navXHTML, tagLevels.size()*2);
}
else
{
gsf_xml_out_start_element(navXHTML, "ol");
gsf_xml_out_start_element(navXHTML, "li");
gsf_xml_out_add_cstr(navXHTML, "class", "h1");
gsf_xml_out_add_cstr(navXHTML, "id", "index");
gsf_xml_out_start_element(navXHTML, "a");
gsf_xml_out_add_cstr(navXHTML, "href", "index.xhtml");
gsf_xml_out_add_cstr(navXHTML, NULL, getTitle().c_str());
gsf_xml_out_end_element(navXHTML);
gsf_xml_out_end_element(navXHTML);
gsf_xml_out_end_element(navXHTML);
}
gsf_xml_out_end_element(navXHTML);
// </section>
gsf_xml_out_end_element(navXHTML);
gsf_xml_out_end_element(navXHTML);
gsf_xml_out_end_element(navXHTML);
gsf_output_close(nav);
return UT_OK;
}
UT_Error IE_Exp_EPUB::EPUB2_writeNavigation()
{
GsfOutput* ncx = gsf_outfile_new_child(GSF_OUTFILE(m_oebps), "toc.ncx",
FALSE);
if (ncx == NULL)
{
UT_DEBUGMSG(("Can`t create toc.ncx file\n"));
return UT_ERROR;
}
GsfXMLOut* ncxXml = gsf_xml_out_new(ncx);
// <ncx>
gsf_xml_out_start_element(ncxXml, "ncx");
gsf_xml_out_add_cstr(ncxXml, "xmlns", NCX_NAMESPACE);
gsf_xml_out_add_cstr(ncxXml, "version", "2005-1");
gsf_xml_out_add_cstr(ncxXml, "xml:lang", NULL);
// <head>
gsf_xml_out_start_element(ncxXml, "head");
// <meta name="dtb:uid" content=... >
gsf_xml_out_start_element(ncxXml, "meta");
gsf_xml_out_add_cstr(ncxXml, "name", "dtb:uid");
gsf_xml_out_add_cstr(ncxXml, "content", getDoc()->getDocUUIDString());
// </meta>
gsf_xml_out_end_element(ncxXml);
// <meta name="epub-creator" content=... >
gsf_xml_out_start_element(ncxXml, "meta");
gsf_xml_out_add_cstr(ncxXml, "name", "epub-creator");
gsf_xml_out_add_cstr(ncxXml, "content",
"AbiWord (http://www.abisource.com/)");
// </meta>
gsf_xml_out_end_element(ncxXml);
// <meta name="dtb:depth" content=... >
gsf_xml_out_start_element(ncxXml, "meta");
gsf_xml_out_add_cstr(ncxXml, "name", "dtb:depth");
gsf_xml_out_add_cstr(ncxXml, "content", "1");
// </meta>
gsf_xml_out_end_element(ncxXml);
// <meta name="dtb:totalPageCount" content=... >
gsf_xml_out_start_element(ncxXml, "meta");
gsf_xml_out_add_cstr(ncxXml, "name", "dtb:totalPageCount");
gsf_xml_out_add_cstr(ncxXml, "content", "0");
// </meta>
gsf_xml_out_end_element(ncxXml);
// <meta name="dtb:totalPageCount" content=... >
gsf_xml_out_start_element(ncxXml, "meta");
gsf_xml_out_add_cstr(ncxXml, "name", "dtb:maxPageCount");
gsf_xml_out_add_cstr(ncxXml, "content", "0");
// </meta>
gsf_xml_out_end_element(ncxXml);
// </head>
gsf_xml_out_end_element(ncxXml);
// <docTitle>
gsf_xml_out_start_element(ncxXml, "docTitle");
gsf_xml_out_start_element(ncxXml, "text");
gsf_xml_out_add_cstr(ncxXml, NULL, getTitle().c_str());
gsf_xml_out_end_element(ncxXml);
// </docTitle>
gsf_xml_out_end_element(ncxXml);
// <docAuthor>
gsf_xml_out_start_element(ncxXml, "docAuthor");
gsf_xml_out_start_element(ncxXml, "text");
gsf_xml_out_add_cstr(ncxXml, NULL, getAuthor().c_str());
gsf_xml_out_end_element(ncxXml);
// </docAuthor>
gsf_xml_out_end_element(ncxXml);
// <navMap>
gsf_xml_out_start_element(ncxXml, "navMap");
if (m_pHmtlExporter->getNavigationHelper()->hasTOC())
{
int lastItemLevel;
int curItemLevel = 0;
std::vector<int> tagLevels;
int tocNum = 0;
for (int currentItem = 0;
currentItem < m_pHmtlExporter->getNavigationHelper()->getNumTOCEntries();
currentItem++)
{
lastItemLevel = curItemLevel;
std::string itemStr = m_pHmtlExporter->getNavigationHelper()
->getNthTOCEntry(currentItem, &curItemLevel).utf8_str();
PT_DocPosition itemPos;
m_pHmtlExporter->getNavigationHelper()->getNthTOCEntryPos(currentItem, itemPos);
std::string itemFilename;
if (m_exp_opt.bSplitDocument)
{
itemFilename = m_pHmtlExporter->getNavigationHelper()
->getFilenameByPosition(itemPos).utf8_str();
if (itemFilename.length() == 0 || (itemFilename[0] == '.'))
{
itemFilename = "index.xhtml";
}
else
{
itemFilename += + ".xhtml";
}
} else
{
itemFilename = "index.xhtml";
}
if (std::find(m_opsId.begin(), m_opsId.end(),
escapeForId(itemFilename)) == m_opsId.end())
{
m_opsId.push_back(escapeForId(itemFilename));
tocNum = 0;
}
UT_DEBUGMSG(("Item filename %s at pos %d\n",
itemFilename.c_str(),itemPos));
if ((lastItemLevel >= curItemLevel) && (currentItem != 0))
{
while ((tagLevels.size() > 0)
&& (tagLevels.back() >= curItemLevel))
{
gsf_xml_out_end_element(ncxXml);
tagLevels.pop_back();
}
}
std::string navClass = UT_std_string_sprintf("h%d", curItemLevel);
std::string navId = UT_std_string_sprintf("AbiTOC%d", tocNum);
std::string navSrc = std::string(itemFilename.c_str()) + "#" + navId;
gsf_xml_out_start_element(ncxXml, "navPoint");
gsf_xml_out_add_cstr(ncxXml, "playOrder",
UT_std_string_sprintf("%d", currentItem + 1).c_str());
gsf_xml_out_add_cstr(ncxXml, "class", navClass.c_str());
gsf_xml_out_add_cstr(ncxXml, "id", navId.c_str());
gsf_xml_out_start_element(ncxXml, "navLabel");
gsf_xml_out_start_element(ncxXml, "text");
gsf_xml_out_add_cstr(ncxXml, NULL, itemStr.c_str());
gsf_xml_out_end_element(ncxXml);
gsf_xml_out_end_element(ncxXml);
gsf_xml_out_start_element(ncxXml, "content");
gsf_xml_out_add_cstr(ncxXml, "src", navSrc.c_str());
gsf_xml_out_end_element(ncxXml);
tagLevels.push_back(curItemLevel);
tocNum++;
}
closeNTags(ncxXml, tagLevels.size());
}
else
{
m_opsId.push_back(escapeForId("index.xhtml"));
gsf_xml_out_start_element(ncxXml, "navPoint");
gsf_xml_out_add_cstr(ncxXml, "playOrder", "1");
gsf_xml_out_add_cstr(ncxXml, "class", "h1");
gsf_xml_out_add_cstr(ncxXml, "id", "index");
gsf_xml_out_start_element(ncxXml, "navLabel");
gsf_xml_out_start_element(ncxXml, "text");
gsf_xml_out_add_cstr(ncxXml, NULL, getTitle().c_str());
gsf_xml_out_end_element(ncxXml);
gsf_xml_out_end_element(ncxXml);
gsf_xml_out_start_element(ncxXml, "content");
gsf_xml_out_add_cstr(ncxXml, "src", "index.xhtml");
gsf_xml_out_end_element(ncxXml);
gsf_xml_out_end_element(ncxXml);
}
// </navMap>
gsf_xml_out_end_element(ncxXml);
// </ncx>
gsf_xml_out_end_element(ncxXml);
gsf_output_close(ncx);
return UT_OK;
}
UT_Error IE_Imp_StarOffice::_loadFile(GsfInput * input)
{
try {
UT_DEBUGMSG(("SDW: Starting import\n"));
mOle = GSF_INFILE (gsf_infile_msole_new(input, NULL));
if (!mOle)
return UT_IE_BOGUSDOCUMENT;
// firstly, load metadata
SDWDocInfo::load(mOle, getDoc());
mDocStream = gsf_infile_child_by_name(mOle, "StarWriterDocument");
if (!mDocStream)
return UT_IE_BOGUSDOCUMENT;
gsf_off_t size = gsf_input_size(mDocStream);
if (!appendStrux(PTX_Section, PP_NOPROPS))
return UT_IE_NOMEMORY;
UT_DEBUGMSG(("SDW: Attempting to load DocHdr...\n"));
mDocHdr.load(mDocStream);
UT_DEBUGMSG(("SDW: ...success\n"));
// Ask for and verify the password
if (mDocHdr.cryptor) {
if (!mDocHdr.cryptor->SetPassword(GetPassword().c_str())) {
UT_DEBUGMSG(("SDW: Wrong password\n"));
return UT_IE_PROTECTED;
}
}
// do the actual reading
char type;
bool done = false;
UT_uint32 recSize;
while (!done) {
if (gsf_input_tell(mDocStream) == size)
break;
readChar(mDocStream, type);
gsf_off_t eor;
readRecSize(mDocStream, recSize, &eor);
switch (type) {
case SWG_CONTENTS: {
gsf_off_t flagsEnd = 0;
UT_uint32 nNodes;
// sw/source/core/sw3io/sw3sectn.cxx#L129
if (mDocHdr.nVersion >= SWG_LAYFRAMES) {
UT_uint8 flags;
readFlagRec(mDocStream, flags, &flagsEnd);
}
if (mDocHdr.nVersion >= SWG_LONGIDX)
streamRead(mDocStream, nNodes);
else {
if (mDocHdr.nVersion >= SWG_LAYFRAMES) {
UT_uint16 sectidDummy;
streamRead(mDocStream, sectidDummy);
}
UT_uint16 nodes16;
streamRead(mDocStream, nodes16);
nNodes = (UT_uint32)nodes16;
}
if (flagsEnd) {
UT_ASSERT(flagsEnd >= gsf_input_tell(mDocStream));
if (gsf_input_tell(mDocStream) != flagsEnd) {
UT_DEBUGMSG(("SDW: have not read all flags\n"));
if (gsf_input_seek(mDocStream, flagsEnd, G_SEEK_SET))
return UT_IE_BOGUSDOCUMENT;
}
}
bool done2 = false;
UT_uint32 size2;
while (!done2) {
readChar(mDocStream, type);
gsf_off_t eor2;
readRecSize(mDocStream, size2, &eor2);
switch (type) {
case SWG_TEXTNODE: { // sw/source/core/sw3io/sw3nodes.cxx#L788
UT_DEBUGMSG(("SDW: Found Textnode! (start at 0x%08llX end at 0x%08llX)\n",
(long long)gsf_input_tell(mDocStream),
(long long)eor2));
UT_uint8 flags;
gsf_off_t newPos;
readFlagRec(mDocStream, flags, &newPos);
// XXX check flags
if (gsf_input_seek(mDocStream, newPos, G_SEEK_SET))
return UT_IE_BOGUSDOCUMENT;
// Read the actual text
UT_UCS4Char* str;
readByteString(mDocStream, str);
UT_UCS4String textNode(str);
free(str);
UT_DEBUGMSG(("SDW: ...length=%zu contents are: |%s|\n", textNode.length(), textNode.utf8_str()));
// now get the attributes
UT_String attrs;
UT_String pAttrs;
UT_Vector charAttributes;
while (gsf_input_tell(mDocStream) < eor2) {
char attVal;
streamRead(mDocStream, attVal);
UT_uint32 attSize;
gsf_off_t eoa; // end of attribute
readRecSize(mDocStream, attSize, &eoa);
if (attVal == SWG_ATTRIBUTE) {
TextAttr* a = new TextAttr;
streamRead(mDocStream, *a, eoa);
UT_DEBUGMSG(("SDW: ...found text-sub-node, which=0x%x, ver=0x%x, start=%u, end=%u - data:%s len:%llu data is:",
a->which, a->ver, a->start,
a->end, a->data?"Yes":"No",
(long long unsigned)a->dataLen));
#ifdef DEBUG
hexdump(a->data, a->dataLen);
putc('\n', stderr);
#endif
charAttributes.addItem(a);
}
else if (attVal == SWG_ATTRSET) {
// bah, yet another loop
UT_DEBUGMSG(("SDW: ...paragraph attributes found\n"));
while (gsf_input_tell(mDocStream) < eoa) {
// reusing attVal and attSize
streamRead(mDocStream, attVal);
gsf_off_t eoa2; // end of attribute
readRecSize(mDocStream, attSize, &eoa2);
if (attVal == SWG_ATTRIBUTE) {
TextAttr a;
streamRead(mDocStream, a, eoa2);
if (!a.attrVal.empty()) {
if (a.isPara)
UT_String_setProperty(pAttrs, a.attrName, a.attrVal);
else
UT_String_setProperty(attrs, a.attrName, a.attrVal);
}
UT_DEBUGMSG(("SDW: ......found paragraph attr, which=0x%x, ver=0x%x, start=%u, end=%u (string now %s) Data:%s Len=%lld Data:", a.which, a.ver, (a.startSet?a.start:0), (a.endSet?a.end:0), attrs.c_str(), (a.data ? "Yes" : "No"), (long long)a.dataLen));
#ifdef DEBUG
hexdump(a.data, a.dataLen);
putc('\n', stderr);
#endif
}
if (gsf_input_seek(mDocStream, eoa2, G_SEEK_SET))
return UT_IE_BOGUSDOCUMENT;
}
}
else {
UT_DEBUGMSG(("SDW: ...unknown attribute '%c' found (start=%" GSF_OFF_T_FORMAT " end=%" GSF_OFF_T_FORMAT ")\n", attVal, gsf_input_tell(mDocStream), eoa));
}
if (gsf_input_seek(mDocStream, eoa, G_SEEK_SET))
return UT_IE_BOGUSDOCUMENT;
}
PP_PropertyVector attributes = {
"props",
pAttrs.c_str()
};
// first, insert the paragraph
if (!appendStrux(PTX_Block, attributes))
return UT_IE_NOMEMORY;
UT_String pca(attrs); // character attributes for the whole paragraph
// now insert the spans of text
UT_uint32 len = textNode.length();
UT_uint32 lastInsPos = 0;
for (UT_uint32 i = 1; i < len; i++) {
bool doInsert = false; // whether there was an attribute change
for (UT_sint32 j = 0; j < charAttributes.getItemCount(); j++) {
const TextAttr* a = reinterpret_cast<const TextAttr*>(charAttributes[j]);
// clear the last attribute, if set
if (a->endSet && a->end == (i - 1)) {
if (a->isOff) {
UT_String propval = UT_String_getPropVal(pca, a->attrName);
UT_String_setProperty(attrs, a->attrName, propval);
}
else
UT_String_removeProperty(attrs, a->attrName);
}
// now set new attribute, if needed
if (a->startSet && a->start == (i - 1)) {
if (a->isPara)
UT_String_setProperty(pAttrs, a->attrName, a->attrVal);
else if (a->isOff)
UT_String_removeProperty(attrs, a->attrName);
else
UT_String_setProperty(attrs, a->attrName, a->attrVal);
}
// insert if this is the last character, or if there was a format change
if ((a->endSet && a->end == i) || (a->startSet && a->start == i))
doInsert = true;
}
if (doInsert || i == (len - 1)) {
attributes[1] = attrs.c_str();
UT_DEBUGMSG(("SDW: Going to appendFmt with %s\n", attributes[1].c_str()));
if (!appendFmt(attributes))
return UT_IE_NOMEMORY; /* leave cast alone! */
UT_DEBUGMSG(("SDW: About to insert %u-%u\n", lastInsPos, i));
size_t spanLen = i - lastInsPos;
if (i == (len - 1)) spanLen++;
UT_UCS4String span = textNode.substr(lastInsPos, spanLen);
appendSpan(span.ucs4_str(), spanLen);
lastInsPos = i;
}
}
UT_VECTOR_PURGEALL(TextAttr*, charAttributes);
break;
}
case SWG_JOBSETUP: {
// flags are apparently unused here. no idea why they are there.
gsf_off_t newpos;
UT_uint8 flags;
readFlagRec(mDocStream, flags, &newpos);
if (gsf_input_seek(mDocStream, newpos, G_SEEK_SET))
return UT_IE_BOGUSDOCUMENT;
UT_uint16 len, system;
streamRead(mDocStream, len);
streamRead(mDocStream, system);
char printerName[64];
streamRead(mDocStream, printerName, 64);
char deviceName[32], portName[32], driverName[32];
streamRead(mDocStream, deviceName, 32);
streamRead(mDocStream, portName, 32);
streamRead(mDocStream, driverName, 32);
UT_DEBUGMSG(("SDW: Jobsetup: len %u sys 0x%x printer |%.64s| device |%.32s| port |%.32s| driver |%.32s|\n", len, system, printerName, deviceName, portName, driverName));
if (system == JOBSET_FILE364_SYSTEM || system == JOBSET_FILE605_SYSTEM) {
UT_uint16 len2, system2;
streamRead(mDocStream, len2);
streamRead(mDocStream, system2);
UT_uint32 ddl; // driver data length
streamRead(mDocStream, ddl);
// now the interesting data
UT_uint16 orient; // 0=portrait 1=landscape
streamRead(mDocStream, orient);
UT_uint16 paperBin;
streamRead(mDocStream, paperBin);
UT_uint16 paperFormat;
streamRead(mDocStream, paperFormat);
UT_uint32 width, height;
streamRead(mDocStream, width);
streamRead(mDocStream, height);
UT_DEBUGMSG(("SDW: orient %u bin %u format %u width %u height %u\n", orient, paperBin, paperFormat, width, height));
// rest of the data is ignored, seems to be printer specific anyway.
// Use A4, Portrait by default
PP_PropertyVector attributes = {
"pagetype", "a4", // A4/Letter/...
"orientation", "portrait",
"width", "210",
"height", "297",
"units", "mm"
};
const char* sdwPaperToAbi[] = {
"A3",
"A4",
"A5",
"B4",
"B5",
"Letter",
"Legal",
"Tabloid/Ledger",
"Custom"
};
if (paperFormat < sizeof(sdwPaperToAbi)/sizeof(*sdwPaperToAbi)) {
attributes[1] = sdwPaperToAbi[paperFormat];
}
const char* sdwOrientToAbi[] = {
"portrait",
"landscape"
};
if (orient < sizeof(sdwOrientToAbi)/sizeof(*sdwOrientToAbi)) {
attributes[3] = sdwOrientToAbi[orient];
}
attributes[5] = UT_std_string_sprintf("%f", static_cast<double>(width)/100);
attributes[7] = UT_std_string_sprintf("%f", static_cast<double>(height)/100);
getDoc()->setPageSizeFromFile(attributes);
}
break;
}
case SWG_EOF:
done2 = true;
break;
default:
UT_DEBUGMSG(("SDW: SWG_CONTENT: Skipping %u bytes for record type '%c' (starting at 0x%08llX)\n",
size2, type,
(long long)gsf_input_tell(mDocStream)));
}
if (gsf_input_seek(mDocStream, eor2, G_SEEK_SET))
return UT_IE_BOGUSDOCUMENT;
}
break;
}
case SWG_STRINGPOOL:
{
if (mDocHdr.nVersion <= SWG_POOLIDS) {
UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED);
break;
}
UT_uint8 encoding;
streamRead(mDocStream, encoding);
UT_iconv_t cd = findConverter(encoding);
if (!UT_iconv_isValid(cd))
throw UT_IE_IMPORTERROR;
UT_uint16 count;
streamRead(mDocStream, count);
while (count--) {
UT_uint16 id;
streamRead(mDocStream, id);
char* str;
UT_uint16 len;
::readByteString(mDocStream, str, &len);
if (id == IDX_NOCONV_FF) {
UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED);
}
// FIXME: find a way to not have to copy and free
// the result of UT_convert_cd.... --hub
UT_DEBUGMSG(("SDW: StringPool: found 0x%04x <-> %.*s\n", id, len, str));
UT_UCS4Char* convertedString = reinterpret_cast<UT_UCS4Char*>(UT_convert_cd(str, len + 1, cd, NULL, NULL));
mStringPool.insert(stringpool_map::value_type(id, convertedString));
FREEP(convertedString);
delete [] str;
}
UT_iconv_close(cd);
break;
}
case SWG_COMMENT: // skip over comments
break;
case SWG_EOF:
done = true;
break;
default:
UT_DEBUGMSG(("SDW: Skipping %u bytes for record type '%c' (starting at 0x%08llX)\n", recSize, type, (long long)gsf_input_tell(mDocStream)));
}
// Seek to the end of the record, in case it wasn't read completely
if (gsf_input_seek(mDocStream, eor, G_SEEK_SET))
return UT_IE_BOGUSDOCUMENT;
}
UT_DEBUGMSG(("SDW: Done\n"));
return UT_OK;
}
catch(UT_Error e) {
UT_DEBUGMSG(("SDW: error %d\n", e));
return e;
}
catch(...) {
UT_DEBUGMSG(("SDW: Unknown error\n"));
return UT_IE_BOGUSDOCUMENT;
}
}
/*!
* Import graphic for cell background.
*/
void AP_Dialog_FormatFrame::askForGraphicPathName(void)
{
UT_return_if_fail(m_pApp);
XAP_Frame * pFrame = m_pApp->getLastFocussedFrame();
UT_return_if_fail(pFrame);
XAP_DialogFactory * pDialogFactory
= static_cast<XAP_DialogFactory *>(pFrame->getDialogFactory());
UT_return_if_fail(pDialogFactory);
XAP_Dialog_FileOpenSaveAs * pDialog
= static_cast<XAP_Dialog_FileOpenSaveAs *>(pDialogFactory->requestDialog(XAP_DIALOG_ID_INSERT_PICTURE));
UT_return_if_fail (pDialog);
pDialog->setCurrentPathname(NULL);
pDialog->setSuggestFilename(false);
// to fill the file types popup list, we need to convert AP-level
// ImpGraphic descriptions, suffixes, and types into strings.
UT_uint32 filterCount = IE_ImpGraphic::getImporterCount();
const char ** szDescList = static_cast<const char **>(UT_calloc(filterCount + 1, sizeof(char *)));
const char ** szSuffixList = static_cast<const char **>(UT_calloc(filterCount + 1, sizeof(char *)));
IEGraphicFileType * nTypeList = (IEGraphicFileType *)
UT_calloc(filterCount + 1, sizeof(IEGraphicFileType));
UT_uint32 k = 0;
while (IE_ImpGraphic::enumerateDlgLabels(k, &szDescList[k], &szSuffixList[k], &nTypeList[k]))
k++;
pDialog->setFileTypeList(szDescList, szSuffixList, static_cast<const UT_sint32 *>(nTypeList));
pDialog->runModal(pFrame);
XAP_Dialog_FileOpenSaveAs::tAnswer ans = pDialog->getAnswer();
bool bOK = (ans == XAP_Dialog_FileOpenSaveAs::a_OK);
if (bOK)
{
m_sImagePath = pDialog->getPathname();
UT_sint32 type = pDialog->getFileType();
// If the number is negative, it's a special type.
// Some operating systems which depend solely on filename
// suffixes to identify type (like Windows) will always
// want auto-detection.
if (type < 0)
switch (type)
{
case XAP_DIALOG_FILEOPENSAVEAS_FILE_TYPE_AUTO:
// do some automagical detecting
m_iGraphicType = IEGFT_Unknown;
break;
default:
// it returned a type we don't know how to handle
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
else
m_iGraphicType = static_cast<IEGraphicFileType>(pDialog->getFileType());
}
FREEP(szDescList);
FREEP(szSuffixList);
FREEP(nTypeList);
pDialogFactory->releaseDialog(pDialog);
if(m_sImagePath.size() == 0)
{
return;
}
FG_Graphic* pFG = NULL;
UT_Error errorCode;
errorCode = IE_ImpGraphic::loadGraphic(m_sImagePath.c_str(), m_iGraphicType, &pFG);
if(errorCode != UT_OK || !pFG)
{
ShowErrorBox(m_sImagePath, errorCode);
return;
}
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_pGraphic = pFG->clone();
GR_Graphics * pG = m_pFormatFramePreview->getGraphics();
FV_View * pView = static_cast<FV_View *>(pFrame->getCurrentView());
UT_return_if_fail(pView && pView->getDocument());
UT_uint32 uid = pView->getDocument()->getUID(UT_UniqueId::Image); //see Bug 10851
m_sImagePath.clear();
m_sImagePath = UT_std_string_sprintf("%d",uid);
m_pImage = _makeImageForRaster(m_sImagePath, pG, m_pGraphic);
// draw the preview with the changed properties
if(m_pFormatFramePreview)
m_pFormatFramePreview->draw();
}
bool ODe_ManifestWriter::writeManifest(PD_Document* pDoc, GsfOutfile* pODT)
{
// Create META-INF directory
GsfOutput* meta_inf = gsf_outfile_new_child(pODT, "META-INF", TRUE);
GsfOutput* manifest = gsf_outfile_new_child(
GSF_OUTFILE(meta_inf), "manifest.xml", FALSE);
std::string name;
static const char * const preamble [] = {
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n",
"<!DOCTYPE manifest:manifest PUBLIC \"-//OpenOffice.org//DTD Manifest 1.0//EN\" \"Manifest.dtd\">\n",
"<manifest:manifest xmlns:manifest=\"urn:oasis:names:tc:opendocument:xmlns:manifest:1.0\">\n",
" <manifest:file-entry manifest:media-type=\"application/vnd.oasis.opendocument.text\" manifest:full-path=\"/\"/>\n",
" <manifest:file-entry manifest:media-type=\"text/xml\" manifest:full-path=\"content.xml\"/>\n",
" <manifest:file-entry manifest:media-type=\"text/xml\" manifest:full-path=\"styles.xml\"/>\n",
" <manifest:file-entry manifest:media-type=\"text/xml\" manifest:full-path=\"meta.xml\"/>\n",
" <manifest:file-entry manifest:media-type=\"text/xml\" manifest:full-path=\"settings.xml\"/>\n"
};
static const char * const postamble [] = {
"</manifest:manifest>\n"
};
typedef std::set< std::string > absolutePathMimeTypes_t;
static absolutePathMimeTypes_t absolutePathMimeTypes;
if( absolutePathMimeTypes.empty() )
{
absolutePathMimeTypes.insert("application/rdf+xml");
}
ODe_writeToStream (manifest, preamble, G_N_ELEMENTS(preamble));
const char* szName;
std::string mimeType;
const UT_ByteBuf* pByteBuf;
std::set< std::string > pathsAlreadyWritten;
for (UT_uint32 k = 0;
(pDoc->enumDataItems(k,
NULL,
&szName,
&pByteBuf,
&mimeType)); k++) {
if (!mimeType.empty()) {
ensureDirectoryManifest( pDoc, manifest, szName, pathsAlreadyWritten );
std::string automaticPathPrefix = "Pictures/";
if( absolutePathMimeTypes.count(mimeType) )
automaticPathPrefix = "";
name = UT_std_string_sprintf(
" <manifest:file-entry manifest:media-type=\"%s\" manifest:full-path=\"%s%s\"/>\n",
mimeType.c_str(), automaticPathPrefix.c_str(), szName);
ODe_gsf_output_write (manifest, name.size(),
reinterpret_cast<const guint8 *>(name.c_str()));
}
}
ODe_writeToStream (manifest, postamble, G_N_ELEMENTS(postamble));
ODe_gsf_output_close(manifest);
ODe_gsf_output_close(meta_inf);
return true;
}
void XAP_UnixDialog_MessageBox::runModal(XAP_Frame * pFrame)
{
XAP_UnixFrameImpl * pUnixFrameImpl = static_cast<XAP_UnixFrameImpl *>(pFrame->getFrameImpl());
UT_return_if_fail(pUnixFrameImpl);
XAP_UnixApp * pApp = static_cast<XAP_UnixApp *>(XAP_App::getApp());
UT_return_if_fail(pApp);
GtkWidget * message = 0; // initialize to prevent compiler warning
GtkWindow * toplevel;
toplevel = GTK_WINDOW(pUnixFrameImpl->getTopLevelWindow());
int dflFlags = GTK_DIALOG_MODAL;
int dflResponse = GTK_RESPONSE_OK;
switch (m_buttons)
{
case b_O:
// just put up an information box
message = gtk_message_dialog_new ( toplevel, GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"%s",
m_szMessage ) ;
break;
case b_YN:
// YES - NO - most certainly a question
message = gtk_message_dialog_new ( toplevel, GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
"%s",
m_szMessage ) ;
if(m_defaultAnswer == XAP_Dialog_MessageBox::a_YES)
{
gtk_dialog_set_default_response (GTK_DIALOG(message),
GTK_RESPONSE_YES);
}
else
{
gtk_dialog_set_default_response (GTK_DIALOG(message),
GTK_RESPONSE_NO);
}
break;
case b_YNC:
{
// YES - NO - CANCEL
// this is only used for saving files.
#ifndef EMBEDDED_TARGET
std::string no, cancel, save;
std::string labelText;
const XAP_StringSet * pSS = pApp->getStringSet ();
message = gtk_dialog_new_with_buttons("",
toplevel,
static_cast<GtkDialogFlags>(dflFlags),
NULL, NULL);
pSS->getValueUTF8(XAP_STRING_ID_DLG_Exit_CloseWithoutSaving, no);
pSS->getValueUTF8(XAP_STRING_ID_DLG_Cancel, cancel);
pSS->getValueUTF8(XAP_STRING_ID_DLG_Save, save);
gtk_dialog_add_buttons(GTK_DIALOG(message),
convertMnemonics(no).c_str(),
GTK_RESPONSE_NO,
convertMnemonics(cancel).c_str(),
GTK_RESPONSE_CANCEL,
convertMnemonics(save).c_str(),
GTK_RESPONSE_YES,
NULL);
dflResponse = GTK_RESPONSE_YES;
GtkWidget * label = gtk_label_new(NULL);
const char * separator;
separator = m_szSecondaryMessage ? "\n\n" : "";
gchar * msg = g_markup_escape_text (m_szMessage, -1);
labelText = UT_std_string_sprintf(
"<span weight=\"bold\" size=\"larger\">%s</span>%s%s",
msg, separator, m_szSecondaryMessage);
g_free (msg); msg = NULL;
gtk_label_set_markup(GTK_LABEL(label), labelText.c_str());
GtkWidget * hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (hbox),
gtk_image_new_from_icon_name("dialog-warning",
GTK_ICON_SIZE_DIALOG),
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), label,
TRUE, TRUE, 0);
GtkBox *content_area = GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG(message)));
gtk_box_pack_start (content_area, hbox, FALSE, FALSE, 0);
gtk_box_set_spacing(content_area, 12);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_widget_show_all (hbox);
#else
message = gtk_message_dialog_new (toplevel,
static_cast<GtkDialogFlags>(dflFlags),
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
"%s",
m_szMessage);
gtk_dialog_add_buttons(GTK_DIALOG(message),
GTK_STOCK_NO,
GTK_RESPONSE_NO,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_YES,
GTK_RESPONSE_YES,
NULL);
#endif
gtk_dialog_set_default_response (GTK_DIALOG(message),
GTK_RESPONSE_CANCEL);
break;
}
default:
UT_ASSERT_NOT_REACHED();
}
// set the title to '', as per GNOME HIG, Section 3, Alerts
gtk_window_set_title (GTK_WINDOW(message), "");
UT_ASSERT(message);
switch ( abiRunModalDialog ( GTK_DIALOG(message), pFrame,
this, dflResponse, true, ATK_ROLE_ALERT ) )
{
case GTK_RESPONSE_OK:
m_answer = XAP_Dialog_MessageBox::a_OK;
break;
case GTK_RESPONSE_YES:
m_answer = XAP_Dialog_MessageBox::a_YES;
break;
case GTK_RESPONSE_NO:
m_answer = XAP_Dialog_MessageBox::a_NO;
break;
case GTK_RESPONSE_CANCEL:
default:
m_answer = XAP_Dialog_MessageBox::a_CANCEL; break;
}
}
/*!
\param buf the buffer the image content is in.
\param image_name the image name inside the XML file or the piecetable.
\param imgProps the RTF image properties.
\return true is successful.
Insert and image at the current position.
Check whether we are pasting or importing
*/
bool IE_Imp_RTF::InsertImage (const FG_Graphic *pFG, const char * image_name,
const struct RTFProps_ImageProps & imgProps)
{
std::string propBuffer;
double wInch = 0.0f;
double hInch = 0.0f;
double cropt = 0.0f;
double cropb = 0.0f;
double cropl = 0.0f;
double cropr = 0.0f;
bool resize1 = false;
if (!bUseInsertNotAppend())
{
// non-null file, we're importing a doc
// Now, we should insert the picture into the document
switch (imgProps.sizeType)
{
case RTFProps_ImageProps::ipstGoal:
UT_DEBUGMSG (("Goal\n"));
resize1 = true;
wInch = static_cast<double>(imgProps.wGoal) / 1440.0f;
hInch = static_cast<double>(imgProps.hGoal) / 1440.0f;
break;
case RTFProps_ImageProps::ipstScale:
UT_DEBUGMSG (("Scale: x=%d, y=%d, w=%d, h=%d\n", imgProps.scaleX, imgProps.scaleY, imgProps.width, imgProps.height));
resize1 = true;
if ((imgProps.wGoal != 0) && (imgProps.hGoal != 0)) {
// want image scaled against the w&h specified, not the image's natural size
wInch = ((static_cast<double>(imgProps.scaleX) / 100.0f) * (imgProps.wGoal/ 1440.0f));
hInch = ((static_cast<double>(imgProps.scaleY) / 100.0f) * (imgProps.hGoal/ 1440.0f));
} else {
wInch = ((static_cast<double>(imgProps.scaleX) / 100.0f) * (imgProps.width));
hInch = ((static_cast<double>(imgProps.scaleY) / 100.0f) * (imgProps.height));
}
break;
default:
resize1 = false;
break;
}
if ( imgProps.bCrop )
{
cropt = imgProps.cropt / 1440.0f;
cropb = imgProps.cropb / 1440.0f;
cropl = imgProps.cropl / 1440.0f;
cropr = imgProps.cropr / 1440.0f;
resize1 = true;
}
if (resize1)
{
UT_LocaleTransactor t(LC_NUMERIC, "C");
UT_DEBUGMSG (("resizing...\n"));
propBuffer = UT_std_string_sprintf("width:%fin; height:%fin; cropt:%fin; cropb:%fin; cropl:%fin; cropr:%fin",
wInch, hInch, cropt, cropb, cropl, cropr);
UT_DEBUGMSG (("props are %s\n", propBuffer.c_str()));
}
const gchar* propsArray[5];
propsArray[0] = static_cast<const gchar *>("dataid");
propsArray[1] = static_cast<const gchar *>(image_name);
if (resize1)
{
propsArray[2] = static_cast<const gchar *>("props");
propsArray[3] = propBuffer.c_str();
propsArray[4] = NULL;
}
else
{
propsArray[2] = NULL;
}
if(!isStruxImage())
{
xxx_UT_DEBUGMSG(("SEVIOR: Appending Object 2 m_bCellBlank %d m_bEndTableOpen %d \n",m_bCellBlank,m_bEndTableOpen));
if(m_bCellBlank || m_bEndTableOpen)
{
xxx_UT_DEBUGMSG(("Append block 13 \n"));
getDoc()->appendStrux(PTX_Block,NULL);
m_bCellBlank = false;
m_bEndTableOpen = false;
}
if (!getDoc()->appendObject(PTO_Image, propsArray))
{
return false;
}
}
if (!getDoc()->createDataItem(image_name, false,
pFG->getBuffer(), pFG->getMimeType(),
NULL))
{
// taken care of by createDataItem
//FREEP(mimetype);
return false;
}
if(isStruxImage())
{
m_sImageName = image_name;
}
else
{
clearImageName();
}
}
else
{
// null file, we're pasting an image. this really makes
// quite a difference to the piece table
// Get a unique name for image.
UT_ASSERT_HARMLESS(image_name);
std::string szName;
#if 0
if( !image_name)
{
image_name = "image_z";
}
UT_uint32 ndx = 0;
for (;;)
{
szName = UT_std_string_sprintf("%s_%d", image_name, ndx);
if (!getDoc()->getDataItemDataByName(szName.c_str(), NULL, NULL, NULL))
{
break;
}
ndx++;
}
#else
UT_uint32 iid = getDoc()->getUID(UT_UniqueId::Image);
szName = UT_std_string_sprintf("%d", iid);
#endif
//
// Code from fg_GraphicsRaster.cpp
//
/*
Create the data item
*/
bool bOK = false;
bOK = getDoc()->createDataItem(szName.c_str(), false,
pFG->getBuffer(),
pFG->getMimeType(), NULL);
UT_return_val_if_fail(bOK, false);
/*
Insert the object into the document.
*/
bool resize = false;
switch (imgProps.sizeType)
{
case RTFProps_ImageProps::ipstGoal:
UT_DEBUGMSG (("Goal\n"));
resize = true;
wInch = static_cast<double>(imgProps.wGoal) / 1440.0f;
hInch = static_cast<double>(imgProps.hGoal) / 1440.0f;
break;
case RTFProps_ImageProps::ipstScale:
UT_DEBUGMSG (("Scale: x=%d, y=%d, w=%d, h=%d\n", imgProps.scaleX, imgProps.scaleY, imgProps.width, imgProps.height));
resize = true;
if ((imgProps.wGoal != 0) && (imgProps.hGoal != 0)) {
// want image scaled against the w&h specified, not the image's natural size
wInch = ((static_cast<double>(imgProps.scaleX) / 100.0f) * imgProps.wGoal/ 1440.0f);
hInch = ((static_cast<double>(imgProps.scaleY) / 100.0f) * imgProps.hGoal/ 1440.0f);
} else {
wInch = ((static_cast<double>(imgProps.scaleX) / 100.0f) * (imgProps.width));
hInch = ((static_cast<double>(imgProps.scaleY) / 100.0f) * (imgProps.height));
}
break;
default:
resize = false;
break;
}
if (resize)
{
UT_LocaleTransactor t(LC_NUMERIC, "C");
UT_DEBUGMSG (("resizing...\n"));
propBuffer = UT_std_string_sprintf("width:%fin; height:%fin",
wInch, hInch);
UT_DEBUGMSG (("props are %s\n", propBuffer.c_str()));
}
const gchar* propsArray[5];
propsArray[0] = static_cast<const gchar *>("dataid");
propsArray[1] = static_cast<const gchar *>(szName.c_str());
if (resize)
{
propsArray[2] = static_cast<const gchar *>("props");
propsArray[3] = propBuffer.c_str();
propsArray[4] = NULL;
}
else
{
propsArray[2] = NULL;
}
m_sImageName = szName.c_str();
if(!isStruxImage())
{
getDoc()->insertObject(m_dposPaste, PTO_Image, propsArray, NULL);
m_dposPaste++;
}
}
return true;
}