const char * AbiWordperfectInputStream::subStreamName(unsigned id)
{
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL));
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_zip_new (m_input, NULL));
if (m_ole)
{
if ((int)id >= gsf_infile_num_children(m_ole))
{
return 0;
}
std::map<unsigned, std::string>::iterator i = m_substreams.lower_bound(id);
if (i == m_substreams.end() || m_substreams.key_comp()(id, i->first))
{
std::string name = gsf_infile_name_by_index(m_ole, (int)id);
i = m_substreams.insert(i, std::map<unsigned, std::string>::value_type(id, name));
}
return i->second.c_str();
}
return 0;
}
int
main (int argc, char *argv[])
{
GHashTable * human_readable_keys;
int i;
if (argc < 2)
{
fprintf (stderr, _("Usage: wvSummary doc1 [... docN]\n"));
return 1;
}
wvInit();
human_readable_keys = g_hash_table_new (g_str_hash,
g_str_equal);
for (i = 0; i < nr_metadata_names; i++)
g_hash_table_insert (human_readable_keys,
metadata_names[i].metadata_key,
_(metadata_names[i].human_readable_key));
for (i = 1 ; i < argc ; i++)
{
GsfInput *input;
GsfInfile *msole;
GError *err = NULL;
input = gsf_input_stdio_new (argv[i], &err);
if(!input)
{
fprintf (stderr, _("Problem with getting metadata from %s:%s\n"),
argv[i], err ? err->message : "");
g_error_free (err);
continue;
}
input = gsf_input_uncompress (input);
msole = gsf_infile_msole_new (input, &err);
if(!msole)
{
fprintf (stderr, _("Problem with getting metadata from %s:%s\n"),
argv[i], err ? err->message : "");
g_error_free (err);
continue;
}
fprintf (stdout, _("Metadata for %s:\n"), argv[i]);
print_summary_stream (msole, argv[i], "\05SummaryInformation", human_readable_keys);
print_summary_stream (msole, argv[i], "\05DocumentSummaryInformation", human_readable_keys);
g_object_unref (G_OBJECT (msole));
g_object_unref (G_OBJECT (input));
}
g_hash_table_destroy (human_readable_keys);
wvShutdown();
return 0;
}
static void
read_thumbnail_and_write (const char *in_filename, const char *out_filename, int thumb_size)
{
GsfInput *input;
GsfInfile *infile;
GError *error;
input = gsf_input_mmap_new (in_filename, NULL);
if (!input) {
error = NULL;
input = gsf_input_stdio_new (in_filename, &error);
if (!input)
show_error_and_exit (error);
}
input = gsf_input_uncompress (input);
error = NULL;
if (NULL != (infile = gsf_infile_msole_new (input, &error)))
msole_thumbnail (infile, out_filename, thumb_size);
else if (NULL != (infile = gsf_infile_zip_new (input, &error)))
zip_thumbnail (infile, out_filename, thumb_size);
else
show_error_and_exit (error);
g_object_unref (infile);
g_object_unref (input);
}
bool AbiWordperfectInputStream::isOLEStream()
{
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL));
if (m_ole != NULL)
return true;
return false;
}
/**
* gsf_input_find_vba:
* @input: #GsfInput
* @err: #GError, optionally %NULL.
*
* A utility routine that attempts to find the VBA file withint a stream.
*
* Returns: (transfer full): a GsfInfile
**/
GsfInfileMSVBA *
gsf_input_find_vba (GsfInput *input, GError **err)
{
GsfInput *vba = NULL;
GsfInfile *infile;
if (NULL != (infile = gsf_infile_msole_new (input, NULL))) {
/* 1) Try XLS */
vba = gsf_infile_child_by_vname (infile, "_VBA_PROJECT_CUR", "VBA", NULL);
/* 2) DOC */
if (NULL == vba)
vba = gsf_infile_child_by_vname (infile, "Macros", "VBA", NULL);
/* TODO : PPT is more complex */
g_object_unref (infile);
} else if (NULL != (infile = gsf_infile_zip_new (input, NULL))) {
GsfInput *main_part = gsf_open_pkg_open_rel_by_type (GSF_INPUT (infile),
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
NULL);
if (NULL != main_part) {
GsfInput *vba_stream = gsf_open_pkg_open_rel_by_type (main_part,
"http://schemas.microsoft.com/office/2006/relationships/vbaProject",
NULL);
if (NULL != vba_stream) {
GsfInfile *ole = gsf_infile_msole_new (vba_stream, err);
if (NULL != ole) {
vba = gsf_infile_child_by_vname (ole, "VBA", NULL);
g_object_unref (ole);
}
g_object_unref (vba_stream);
}
g_object_unref (main_part);
}
g_object_unref (infile);
}
if (NULL != vba)
return (GsfInfileMSVBA *)
gsf_infile_msvba_new (GSF_INFILE (vba), err);
return NULL;
}
UT_Error IE_Imp_Hancom::_loadFile(GsfInput * input) {
mDoc = GSF_INFILE(gsf_infile_msole_new (input, NULL));
if (!mDoc)
return UT_IE_BOGUSDOCUMENT;
GsfInput *textStream = gsf_infile_child_by_name(mDoc, "/PrvText");
if (!textStream)
return UT_IE_BOGUSDOCUMENT;
size_t len = gsf_input_size(textStream);
UT_DEBUGMSG(("HANCOM: Text length = %zd bytes\n", len));
unsigned char* buf = new unsigned char[len];
if (!buf) {
g_object_unref (G_OBJECT (textStream));
return UT_IE_NOMEMORY;
}
gsf_input_read(textStream, len, buf);
g_object_unref (G_OBJECT (textStream));
UT_uint32 length;
UT_UCS4Char* text = reinterpret_cast<UT_UCS4Char*>(UT_convert((const char *)buf, len, "UCS-2LE",
UCS_INTERNAL, NULL, &length));
delete[] buf;
if (!text)
return UT_IE_NOMEMORY;
UT_DEBUGMSG(("HANCOM: Text successfully converted.\n"));
if (!appendStrux(PTX_Section, NULL)) {
FREEP(text);
return UT_IE_NOMEMORY;
}
if (!appendStrux(PTX_Block, NULL)) {
FREEP(text);
return UT_IE_NOMEMORY;
}
if (!appendSpan(text, length/4)) {
FREEP(text);
return UT_IE_NOMEMORY;
}
FREEP(text);
return UT_OK;
}
static int
test (char *argv[])
{
GsfInput *input;
GsfInfile *infile;
GsfOutput *output;
GsfOutfile *outfile;
GError *err = NULL;
fprintf (stderr, "%s\n", argv [1]);
input = gsf_input_stdio_new (argv[1], &err);
if (input == NULL) {
g_return_val_if_fail (err != NULL, 1);
g_warning ("'%s' error: %s", argv[1], err->message);
g_error_free (err);
return 1;
}
infile = gsf_infile_msole_new (input, &err);
g_object_unref (G_OBJECT (input));
if (infile == NULL) {
g_return_val_if_fail (err != NULL, 1);
g_warning ("'%s' Not an OLE file: %s", argv[1], err->message);
g_error_free (err);
return 1;
}
output = gsf_output_stdio_new (argv[2], &err);
if (output == NULL) {
g_return_val_if_fail (err != NULL, 1);
g_warning ("'%s' error: %s", argv[2], err->message);
g_error_free (err);
g_object_unref (G_OBJECT (infile));
return 1;
}
outfile = gsf_outfile_msole_new (output);
g_object_unref (G_OBJECT (output));
clone (GSF_INPUT (infile), GSF_OUTPUT (outfile));
return 0;
}
unsigned AbiWordperfectInputStream::subStreamCount()
{
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL));
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_zip_new (m_input, NULL));
if (m_ole)
{
int numChildren = gsf_infile_num_children(m_ole);
if (numChildren > 0)
return numChildren;
return 0;
}
return 0;
}
UT_Confidence_t IE_Imp_StarOffice_Sniffer::recognizeContents(GsfInput * input) {
GsfInfile * ole;
UT_Confidence_t confidence = UT_CONFIDENCE_ZILCH;
ole = gsf_infile_msole_new (input, NULL);
if (ole)
{
GsfInput * starWriterDocument = gsf_infile_child_by_name (ole, "StarWriterDocument");
if (starWriterDocument != NULL)
{
confidence = UT_CONFIDENCE_PERFECT;
g_object_unref (G_OBJECT (starWriterDocument));
}
g_object_unref (G_OBJECT (ole));
}
return confidence;
}
WPXInputStream * AbiWordperfectInputStream::getDocumentOLEStream(const char * name)
{
WPXInputStream *documentStream = NULL;
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL));
if (m_ole)
{
GsfInput *document = gsf_infile_child_by_name(m_ole, name);
if (document)
{
documentStream = new AbiWordperfectInputStream(document);
g_object_unref(G_OBJECT (document)); // the only reference should be encapsulated within the new stream
}
}
return documentStream;
}
bool AbiWordperfectInputStream::existsSubStream(const char * name)
{
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL));
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_zip_new (m_input, NULL));
if (m_ole)
{
GsfInput *document = gsf_infile_child_by_name(m_ole, name);
if (document)
{
g_object_unref(G_OBJECT (document));
return true;
}
}
return false;
}
HRESULT STDMETHODCALLTYPE
OMGSFIStorage::StgOpenStorageEx( const TCHAR FAR* in_filename,
OMFile::OMAccessMode in_accessMode,
void **out_storage)
{
TRACE("OMGSFIStorage::StgOpenStorageEx");
PRECONDITION("Valid access mode", in_accessMode == OMFile::readOnlyMode);
GsfStorage *storage = 0;
*out_storage = 0;
char storageName[FILENAME_MAX];
#ifndef OM_UNICODE_APIS
strncpy (storageName, in_filename, sizeof(storageName) -1);
storageName[sizeof(storageName) -1] = '\0';
#else
convertWideStringToString (storageName, in_filename, FILENAME_MAX);
#endif
GError *err;
int status = GSTG_OK;
GsfInput *input = GSF_INPUT (gsf_input_stdio_new (storageName, &err));
if (input != NULL)
{
input = gsf_input_uncompress (input);
storage = GSF_INFILE (gsf_infile_msole_new (input, &err));
g_object_unref (G_OBJECT (input));
}
else
status = GSTG_ERROR;
if (status == GSTG_OK)
{
OMGSFIStorage *newStorage = new OMGSFIStorage (storage, GSF_READ, storageName);
*out_storage = newStorage;
}
return makeStatus(status);
}
librevenge::RVNGInputStream * AbiWordperfectInputStream::getSubStreamById(unsigned id)
{
librevenge::RVNGInputStream *documentStream = NULL;
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL));
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_zip_new (m_input, NULL));
if (m_ole)
{
GsfInput *document = gsf_infile_child_by_index(m_ole, (int)id);
if (document)
{
documentStream = new AbiWordperfectInputStream(document);
g_object_unref(G_OBJECT (document)); // the only reference should be encapsulated within the new stream
}
}
return documentStream;
}
gboolean
qpro_file_probe (GOFileOpener const *fo, GsfInput *input, GOFileProbeLevel pl)
{
GsfInfile *ole;
GsfInput *stream;
gboolean res = FALSE;
/* check for >= QPro 6.0 which is OLE based */
ole = gsf_infile_msole_new (input, NULL);
if (ole != NULL) {
stream = gsf_infile_child_by_name (GSF_INFILE (ole),
"PerfectOffice_MAIN");
if (stream != NULL) {
res = qpro_check_signature (stream);
g_object_unref (stream);
}
g_object_unref (ole);
} else
res = qpro_check_signature (input);
return res;
}
static GsfInfile *
open_archive (char const *filename)
{
GsfInfile *infile;
GError *error = NULL;
GsfInput *src;
char *display_name;
src = gsf_input_stdio_new (filename, &error);
if (error) {
display_name = g_filename_display_name (filename);
g_printerr (_("%s: Failed to open %s: %s\n"),
g_get_prgname (),
display_name,
error->message);
g_free (display_name);
return NULL;
}
infile = gsf_infile_zip_new (src, NULL);
if (infile)
return infile;
infile = gsf_infile_msole_new (src, NULL);
if (infile)
return infile;
infile = gsf_infile_tar_new (src, NULL);
if (infile)
return infile;
display_name = g_filename_display_name (filename);
g_printerr (_("%s: Failed to recognize %s as an archive\n"),
g_get_prgname (),
display_name);
g_free (display_name);
return NULL;
}
/**
* hwp_hwp5_file_new_for_path:
* @path: path of the file to load
* @error: location to store the error occurring, or %NULL to ignore
*
* Creates a new #HwpHWP5File. If %NULL is returned, then @error will be
* set. Possible errors include those in the #HWP_ERROR and #HWP_FILE_ERROR
* domains.
*
* Returns: A newly created #HwpHWP5File, or %NULL
*
* Since: 0.0.1
*/
HwpHWP5File *hwp_hwp5_file_new_for_path (const gchar *path, GError **error)
{
g_return_val_if_fail (path != NULL, NULL);
GsfInput *input;
GsfInfile *olefile;
if ((input = gsf_input_stdio_new (path, error))) {
if ((olefile = gsf_infile_msole_new (input, error))) {
HwpHWP5File *file = g_object_new (HWP_TYPE_HWP5_FILE, NULL);
file->priv->olefile = olefile;
g_object_unref (input);
make_stream (file, error);
return file;
}
}
g_warning("%s:%d: %s\n", __FILE__, __LINE__, (*error)->message);
if (input)
g_object_unref (input);
return NULL;
}
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;
}
}
static int
test (unsigned argc, char *argv[])
{
static char const * const stream_names[] = {
"Workbook", "WORKBOOK", "workbook",
"Book", "BOOK", "book"
};
GsfInput *input, *stream, *pcache_dir;
GsfInfile *infile;
GError *err = NULL;
unsigned i, j;
for (i = 1 ; i < argc ; i++) {
fprintf( stderr, "%s\n",argv[i]);
input = gsf_input_mmap_new (argv[i], NULL);
if (input == NULL) /* Only report error if stdio fails too */
input = gsf_input_stdio_new (argv[i], &err);
if (input == NULL) {
g_return_val_if_fail (err != NULL, 1);
g_warning ("'%s' error: %s", argv[i], err->message);
g_error_free (err);
err = NULL;
continue;
}
input = gsf_input_uncompress (input);
infile = gsf_infile_msole_new (input, &err);
if (infile == NULL) {
g_return_val_if_fail (err != NULL, 1);
g_warning ("'%s' Not an OLE file: %s", argv[i], err->message);
g_error_free (err);
err = NULL;
#ifdef DUMP_CONTENT
dump_biff_stream (input);
#endif
g_object_unref (G_OBJECT (input));
continue;
}
#if 0
stream = gsf_infile_child_by_name (infile, "\01CompObj");
if (stream != NULL) {
gsf_off_t len = gsf_input_size (stream);
guint8 const *data = gsf_input_read (stream, len, NULL);
if (data != NULL)
gsf_mem_dump (data, len);
g_object_unref (G_OBJECT (stream));
}
return 0;
#endif
stream = gsf_infile_child_by_name (infile, "\05SummaryInformation");
if (stream != NULL) {
GsfDocMetaData *meta_data = gsf_doc_meta_data_new ();
puts ( "SummaryInfo");
err = gsf_doc_meta_data_read_from_msole (meta_data, stream);
if (err != NULL) {
g_warning ("'%s' error: %s", argv[i], err->message);
g_error_free (err);
err = NULL;
} else
gsf_doc_meta_dump (meta_data);
g_object_unref (meta_data);
g_object_unref (G_OBJECT (stream));
}
stream = gsf_infile_child_by_name (infile, "\05DocumentSummaryInformation");
if (stream != NULL) {
GsfDocMetaData *meta_data = gsf_doc_meta_data_new ();
puts ( "DocSummaryInfo");
err = gsf_doc_meta_data_read_from_msole (meta_data, stream);
if (err != NULL) {
g_warning ("'%s' error: %s", argv[i], err->message);
g_error_free (err);
err = NULL;
} else
gsf_doc_meta_dump (meta_data);
g_object_unref (meta_data);
g_object_unref (G_OBJECT (stream));
}
for (j = 0 ; j < G_N_ELEMENTS (stream_names) ; j++) {
stream = gsf_infile_child_by_name (infile, stream_names[j]);
if (stream != NULL) {
puts (j < 3 ? "Excel97" : "Excel95");
#ifdef DUMP_CONTENT
dump_biff_stream (stream);
#endif
g_object_unref (G_OBJECT (stream));
break;
}
}
#ifdef DUMP_CONTENT
pcache_dir = gsf_infile_child_by_name (infile, "_SX_DB_CUR"); /* Excel 97 */
if (NULL == pcache_dir)
pcache_dir = gsf_infile_child_by_name (infile, "_SX_DB"); /* Excel 95 */
if (NULL != pcache_dir) {
int i, n = gsf_infile_num_children (infile);
for (i = 0 ; i < n ; i++) {
stream = gsf_infile_child_by_index (GSF_INFILE (pcache_dir), i);
if (stream != NULL) {
printf ("=================================================\nPivot cache '%04hX'\n\n", i);
dump_biff_stream (stream);
g_object_unref (G_OBJECT (stream));
}
}
g_object_unref (G_OBJECT (pcache_dir));
}
#endif
g_object_unref (G_OBJECT (infile));
g_object_unref (G_OBJECT (input));
}
return 0;
}
static int
test (int argc, char *argv[])
{
GsfInput *input;
GsfInfile *infile;
GError *err = NULL;
fprintf (stderr, "%s\n", argv [1]);
input = gsf_input_stdio_new (argv[1], &err);
if (input == NULL) {
g_return_val_if_fail (err != NULL, 1);
g_warning ("'%s' error: %s", argv[1], err->message);
g_error_free (err);
return 1;
}
input = gsf_input_uncompress (input);
infile = gsf_infile_msole_new (input, &err);
g_object_unref (G_OBJECT (input));
if (infile == NULL) {
g_return_val_if_fail (err != NULL, 1);
g_warning ("'%s' Not an OLE file: %s", argv[1], err->message);
g_error_free (err);
return 1;
}
if (argc > 2) {
int i;
GsfInput *child, *ptr = GSF_INPUT (infile);
for (i = 2 ; i < argc && ptr != NULL; i++, ptr = child) {
fprintf (stderr, "--> '%s'\n", argv [i]);
if (GSF_IS_INFILE (ptr) &&
gsf_infile_num_children (GSF_INFILE (ptr)) >= 0) {
child = gsf_infile_child_by_name (GSF_INFILE (ptr), argv [i]);
if (child == NULL) {
g_warning ("No child named '%s'", argv [i]);
child = NULL;
}
} else {
g_warning ("stream is not a directory '%s'", argv [i]);
child = NULL;
}
g_object_unref (G_OBJECT (ptr));
}
if (ptr != NULL) {
/* See the comment on is_dir in test-cp-msole.c. */
if (GSF_IS_INFILE (ptr) &&
gsf_infile_num_children (GSF_INFILE (ptr)) >= 0)
ls_R (ptr); /* unrefs infile */
else {
gsf_input_dump (GSF_INPUT (ptr), dump_as_hex);
g_object_unref (G_OBJECT (ptr));
}
}
} else
ls_R (GSF_INPUT (infile)); /* unrefs infile */
return 0;
}
