/*!
* Get all character-related attributes and add them to the document.
*
* It does an appendFmt setting the current character attributes. The next
* appendSpan will use these settings.
*/
UT_Error IE_Imp_Psion::applyCharacterAttributes(const psiconv_character_layout layout)
{
UT_return_val_if_fail(layout != NULL, true /* perhaps should be false, but we want loading to proceed */);
UT_Error res;
class UT_UTF8String props;
// Get all attributes into prop
if ((res = getCharacterAttributes(layout,props)))
return res;
UT_DEBUGMSG(("PSION: Character: %s\n",props.utf8_str()));
// Propare the Fmt properties
const PP_PropertyVector propsArray = {
"props", props.utf8_str(),
};
if (!(appendFmt(propsArray)))
return UT_IE_IMPORTERROR;
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;
}
}
void IE_Imp_WordPerfect::openSpan(const librevenge::RVNGPropertyList &propList)
{
if (m_bHdrFtrOpenCount) return; // HACK
UT_DEBUGMSG(("AbiWordPerfect: Appending current text properties\n"));
const gchar* pProps = "props";
UT_String propBuffer;
UT_String tempBuffer;
// bold
propBuffer += "font-weight:";
propBuffer += (propList["fo:font-weight"] ? propList["fo:font-weight"]->getStr().cstr() : "normal");
// italic
propBuffer += "; font-style:";
propBuffer += (propList["fo:font-style"] ? propList["fo:font-style"]->getStr().cstr() : "normal");
// superscript or subscript
if (propList["style:text-position"])
{
propBuffer += "; text-position:";
if (strncmp(propList["style:text-position"]->getStr().cstr(), "super", 5) == 0)
propBuffer += "superscript";
else
propBuffer += "subscript";
}
if (propList["style:text-underline-type"] || propList["style:text-line-through-type"])
{
propBuffer += "; text-decoration:";
if (propList["style:text-underline-type"])
propBuffer += "underline ";
if (propList["style:text-line-through-type"])
propBuffer += "line-through";
}
if (propList["style:font-name"])
{
propBuffer += "; font-family:";
propBuffer += propList["style:font-name"]->getStr().cstr();
}
// font face
if (propList["fo:font-size"])
{
propBuffer += "; font-size:";
propBuffer += propList["fo:font-size"]->getStr().cstr();
}
if (propList["fo:color"])
{
propBuffer += "; color:";
propBuffer += propList["fo:color"]->getStr().cstr();
}
if (propList["fo:background-color"])
{
propBuffer += "; bgcolor:";
propBuffer += propList["fo:background-color"]->getStr().cstr();
}
UT_DEBUGMSG(("AbiWordPerfect: Appending span format: %s\n", propBuffer.c_str()));
const gchar* propsArray[5];
propsArray[0] = pProps;
propsArray[1] = propBuffer.c_str();
propsArray[2] = NULL;
X_CheckDocumentError(appendFmt(propsArray));
}
bool IE_Imp_MSWrite::read_txt (int from, int to)
{
static const char *currcp;
int fcMac, pnChar, fcFirst, cfod, fc, fcLim;
unsigned char page[0x80];
UT_String properties, tmp;
int dataLen = static_cast<UT_sint32>(mData.getLength());
UT_DEBUGMSG((" TXT:\n"));
UT_DEBUGMSG((" from = %d\n", from));
UT_DEBUGMSG((" to = %d\n", to));
fcMac = wri_struct_value(wri_file_header, "fcMac");
pnChar = (fcMac + 127) / 128;
fcFirst = 0x80;
while (true)
{
gsf_input_seek(mFile, pnChar++ * 0x80, G_SEEK_SET);
gsf_input_read(mFile, 0x80, page);
fc = READ_DWORD(page);
cfod = page[0x7f];
UT_DEBUGMSG((" fcFirst = %d\n", fc));
UT_DEBUGMSG((" cfod = %d\n", cfod));
if (fc != fcFirst) UT_WARNINGMSG(("read_txt: fcFirst wrong.\n"));
// read all FODs (format descriptors)
for (int fod = 0; fod < cfod; fod++)
{
int bfprop, cch, ftc, hps, fBold, fItalic, fUline, hpsPos;
UT_DEBUGMSG((" CHP-FOD #%02d:\n", fod + 1));
// read a FOD (format descriptor)
fcLim = READ_DWORD(page + 4 + fod * 6);
bfprop = READ_WORD(page + 8 + fod * 6);
UT_DEBUGMSG((" fcLim = %d\n", fcLim));
UT_DEBUGMSG((bfprop == 0xffff ? " bfprop = 0x%04X\n" : " bfprop = %d\n", bfprop));
// default CHP values
ftc = 0;
hps = 24;
fBold = fItalic = fUline = hpsPos = 0;
// if the CHP FPROPs (formatting properties) differ from the defaults, get them
if (bfprop != 0xffff && bfprop + (cch = page[bfprop + 4]) < 0x80)
{
UT_DEBUGMSG((" cch = %d\n", cch));
if (cch >= 2) ftc = page[bfprop + 6] >> 2;
if (cch >= 5) ftc |= (page[bfprop + 9] & 3) << 6;
if (cch >= 3) hps = page[bfprop + 7];
if (cch >= 2) fBold = page[bfprop + 6] & 1;
if (cch >= 2) fItalic = page[bfprop + 6] & 2;
if (cch >= 4) fUline = page[bfprop + 8] & 1;
if (cch >= 6) hpsPos = page[bfprop + 10];
}
UT_DEBUGMSG((" ftc = %d\n", ftc));
UT_DEBUGMSG((" hps = %d\n", hps));
UT_DEBUGMSG((" fBold = %d\n", fBold));
UT_DEBUGMSG((" fItalic = %d\n", fItalic));
UT_DEBUGMSG((" fUline = %d\n", fUline));
UT_DEBUGMSG((" hpsPos = %d\n", hpsPos));
if (ftc >= wri_fonts_count)
{
UT_WARNINGMSG(("read_txt: Wrong font code.\n"));
ftc = wri_fonts_count - 1;
}
if (from < fcLim && to >= fcFirst)
{
UT_LocaleTransactor lt(LC_NUMERIC, "C");
UT_String_sprintf(properties, "font-weight:%s",
fBold ? "bold" : "normal");
if (hps != 24)
{
UT_String_sprintf(tmp, "; font-size:%dpt", hps / 2);
properties += tmp;
}
if (fItalic) properties += "; font-style:italic";
if (fUline) properties += "; text-decoration:underline";
if (hpsPos)
{
UT_String_sprintf(tmp, "; text-position:%s",
hpsPos < 128 ? "superscript" : "subscript");
properties += tmp;
}
if (wri_fonts_count)
{
UT_String_sprintf(tmp, "; font-family:%s", wri_fonts[ftc].name);
properties += tmp;
}
if (wri_fonts[ftc].codepage != currcp /*sic!*/)
{
set_codepage(wri_fonts[ftc].codepage);
currcp = wri_fonts[ftc].codepage;
}
mText.clear();
UT_DEBUGMSG((" Text: "));
while (fcFirst <= from && from < fcLim && from <= to && from - 0x80 < dataLen)
translate_char(*mData.getPointer(from++ - 0x80), mText);
UT_DEBUGMSG(("\n"));
// new attributes, only if there was text
if (mText.size() > 0)
{
const gchar *attributes[5];
const UT_UCS4Char *text = mText.ucs4_str(), *p = text;
size_t txtLen;
UT_DEBUGMSG((" Conv: %s\n", mText.utf8_str()));
attributes[0] = PT_PROPS_ATTRIBUTE_NAME;
attributes[1] = properties.c_str();
attributes[2] = NULL;
appendFmt(attributes);
// check for page number (should only be in header or footer)
while (*p && *p != (UT_UCS4Char) 0x01) p++;
if (*p)
{
if (p - text) appendSpan(text, p - text);
attributes[2] = PT_TYPE_ATTRIBUTE_NAME;
attributes[3] = "page_number";
attributes[4] = NULL;
appendObject(PTO_Field, attributes);
txtLen = mText.size() - (p - text) - 1;
p++;
}
else
{
txtLen = mText.size();
p = text;
}
if (txtLen) appendSpan(p, txtLen);
}
}
fcFirst = fcLim;
if (fcLim >= fcMac || fcFirst > to)
{
UT_DEBUGMSG((" CHP-FODs end, fcLim (%d) >= fcMac (%d) or fcFirst (%d) > to (%d)\n", fcLim, fcMac, fcFirst, to));
return true;
}
}
}
