static GSList *
xlsx_write_pivots (XLSXWriteState *state, GsfOutfile *wb_part)
{
GHashTable *caches = excel_collect_pivot_caches (state->base.wb);
GHashTableIter iter;
GSList *refs = NULL;
gpointer key, value;
char const *cache_def_id;
if (caches == NULL)
return NULL;
state->date_fmt = xlsx_pivot_date_fmt ();
state->pivotCache.count = state->pivotTable.count = 0;
state->pivotCache.dir = (GsfOutfile *)gsf_outfile_new_child (state->xl_dir, "pivotCache", TRUE);
state->pivotTable.dir = (GsfOutfile *)gsf_outfile_new_child (state->xl_dir, "pivotTable", TRUE);
g_hash_table_iter_init (&iter, caches);
while (g_hash_table_iter_next (&iter, &key, &value))
if (NULL != key) {
cache_def_id = xlsx_write_pivot_cache_definition (state, wb_part, key, GPOINTER_TO_UINT(value));
refs = g_slist_prepend (refs, (gpointer)cache_def_id);
}
gsf_output_close (GSF_OUTPUT (state->pivotCache.dir));
gsf_output_close (GSF_OUTPUT (state->pivotTable.dir));
g_hash_table_destroy (caches);
go_format_unref (state->date_fmt);
return g_slist_reverse (refs);
}
uint32_t FileWriterI::close() {
if (baseOutfile == NULL) {
WARNING << "ops::msole::FileWriterI::close() : file already closed";
return RET_ERR;
}
// close all opened files.
vector <GsfOutput*> :: iterator iter;
for ( uint32_t i = 0 ; i < openFileHandler.size() ; i++) {
GsfOutput * output = openFileHandler[i];
if (output != NULL) {
gsf_output_close (GSF_OUTPUT (output));
g_object_unref (G_OBJECT (output));
}
}
openFileHandler.clear();
// close all opened directories.
map <std::string, GsfOutput*> :: reverse_iterator rIter;
for ( rIter = openDirList.rbegin( ) ; rIter != openDirList.rend( ) ; rIter++) {
GsfOutput * output = openDirList[rIter->first];
gsf_output_close (GSF_OUTPUT (output));
g_object_unref (G_OBJECT (output));
}
openDirList.clear();
baseOutfile = NULL;
DEBUG << "ops::msole::FileWriterI::close() : file closed";
return RET_OK;
}
static GsfInput *
make_local_copy (FILE *stream, const char *filename, GError **err)
{
GsfOutput *out;
GsfInput *copy = NULL;
out = gsf_output_memory_new ();
while (1) {
guint8 buf[4096];
gssize nread;
nread = fread (buf, 1, sizeof(buf), stream);
if (nread > 0) {
if (!gsf_output_write (out, nread, buf))
goto error;
} else if (nread == 0)
break;
else
goto error;
}
copy = gsf_input_memory_new_clone
(gsf_output_memory_get_bytes (GSF_OUTPUT_MEMORY (out)),
gsf_output_size (out));
gsf_output_close (out);
g_object_unref (out);
if (filename)
gsf_input_set_name_from_filename (GSF_INPUT (copy), filename);
return copy;
error:
if (err) {
char *utf8name = filename
? g_filename_display_name (filename)
: g_strdup ("?");
g_set_error (err, gsf_input_error_id (), 0,
"%s: not a regular file",
utf8name);
g_free (utf8name);
}
gsf_output_close (out);
g_object_unref (out);
return NULL;
}
static void clone(GsfInput * input, GsfOutput * output)
{
guint8 const *data;
size_t len;
int i;
if (gsf_input_size(input) > 0) {
while ((len = gsf_input_remaining(input)) > 0) {
/* copy in odd sized chunks to exercise system */
if (len > 314)
len = 314;
if (NULL == (data = gsf_input_read(input, len, NULL))) {
g_warning("error reading ?");
return;
}
if (!gsf_output_write(output, len, data)) {
g_warning("error writing ?");
return;
}
}
}
gsf_output_close(output);
g_object_unref(G_OBJECT(output));
g_object_unref(G_OBJECT(input));
}
/* Add all the files in the folder under the working_dir to the gst_outfile. */
static void
add_folder_to_gst_outfile (GsfOutfile *gst_outfile,
gchar *working_dir,
gchar *folder)
{
GsfOutfile *gst_dir = GSF_OUTFILE (gsf_outfile_new_child (gst_outfile, folder, TRUE));
gchar *path = g_build_filename (working_dir, folder, NULL);
GDir *dir = g_dir_open (path, 0, NULL);
if (dir)
{
const gchar *file = (const gchar *) NULL;
while ( (file = g_dir_read_name (dir)))
{
add_file_to_gst_outfile (gst_dir, path, file);
}
g_dir_close (dir);
}
gsf_output_close ((GsfOutput *) gst_dir);
g_object_unref (gst_dir);
g_free (path);
}
/**
* gsf_structured_blob_write:
* @blob: #GsfStructuredBlob
* @container: #GsfOutfile
*
* Dumps structured blob @blob onto the @container. Will fail if the output is
* not an Outfile and blob has multiple streams.
*
* Returns: %TRUE on success.
**/
gboolean
gsf_structured_blob_write (GsfStructuredBlob *blob, GsfOutfile *container)
{
GsfOutput *output;
gboolean has_kids;
g_return_val_if_fail (GSF_IS_STRUCTURED_BLOB (blob), FALSE);
g_return_val_if_fail (GSF_IS_OUTFILE (container), FALSE);
has_kids = (blob->children != NULL && blob->children->len > 0);
output = gsf_outfile_new_child (GSF_OUTFILE (container),
gsf_input_name (GSF_INPUT (blob)),
has_kids);
if (has_kids) {
GsfStructuredBlob *child_blob;
unsigned i;
for (i = 0 ; i < blob->children->len ; i++) {
child_blob = g_ptr_array_index (blob->children, i);
if (!gsf_structured_blob_write (child_blob, GSF_OUTFILE (output)))
return FALSE;
}
}
if (blob->data != NULL)
gsf_output_write (output, blob->data->size, blob->data->buf);
gsf_output_close (output);
g_object_unref (output);
return TRUE;
}
static void
gsf_outfile_msole_finalize (GObject *obj)
{
GsfOutfileMSOle *ole = GSF_OUTFILE_MSOLE (obj);
GsfOutput *output = GSF_OUTPUT (obj);
if (!gsf_output_is_closed (output))
gsf_output_close (output);
if (ole->sink != NULL) {
g_object_unref (G_OBJECT (ole->sink));
ole->sink = NULL;
}
switch (ole->type) {
case MSOLE_DIR:
g_slist_free (ole->content.dir.children);
ole->content.dir.children = NULL;
if (ole->content.dir.root_order != NULL)
g_warning ("Finalizing a MSOle Outfile without closing it.");
break;
case MSOLE_SMALL_BLOCK:
g_free (ole->content.small_block.buf);
ole->content.small_block.buf = NULL;
break;
case MSOLE_BIG_BLOCK:
break;
default :
g_warning ("Unknown file type");
}
parent_class->finalize (obj);
}
static int
write_dzi( VipsForeignSaveDz *dz )
{
GsfOutput *out;
char buf[VIPS_PATH_MAX];
char *p;
vips_snprintf( buf, VIPS_PATH_MAX, "%s.dzi", dz->basename );
out = vips_gsf_path( dz->tree, buf, NULL );
vips_snprintf( buf, VIPS_PATH_MAX, "%s", dz->suffix + 1 );
if( (p = (char *) vips__find_rightmost_brackets( buf )) )
*p = '\0';
gsf_output_printf( out, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" );
gsf_output_printf( out, "<Image "
"xmlns=\"http://schemas.microsoft.com/deepzoom/2008\"\n" );
gsf_output_printf( out, " Format=\"%s\"\n", buf );
gsf_output_printf( out, " Overlap=\"%d\"\n", dz->overlap );
gsf_output_printf( out, " TileSize=\"%d\"\n", dz->tile_size );
gsf_output_printf( out, " >\n" );
gsf_output_printf( out, " <Size \n" );
gsf_output_printf( out, " Height=\"%d\"\n", dz->layer->height );
gsf_output_printf( out, " Width=\"%d\"\n", dz->layer->width );
gsf_output_printf( out, " />\n" );
gsf_output_printf( out, "</Image>\n" );
(void) gsf_output_close( out );
g_object_unref( out );
return( 0 );
}
/* Decompress infile in dest_dir. */
static void
decompress_infile (GsfInfile *infile,
gchar *dest_dir)
{
GError *err = (GError *) NULL;
int j = 0;
for (j = 0; j < gsf_infile_num_children (infile); j++)
{
GsfInput *child = gsf_infile_child_by_index (infile, j);
char const* filename = gsf_input_name (child);
gboolean is_dir = gsf_infile_num_children (GSF_INFILE (child)) >= 0;
if (is_dir)
{
gchar *dir_path = g_build_filename (dest_dir, filename, (gchar *) 0);
decompress_infile (GSF_INFILE (child), dir_path);
g_free (dir_path);
}
else
{
gchar *file_path = g_build_filename (dest_dir, filename, (gchar *) 0);
GsfOutput *output = GSF_OUTPUT (gsf_output_stdio_new (file_path, &err));
gsf_input_copy (child, output);
gsf_output_close (output);
g_object_unref (output);
g_free (file_path);
}
g_object_unref (G_OBJECT (child));
}
}
static char const *
xlsx_write_pivot_cache_definition (XLSXWriteState *state, GsfOutfile *wb_part,
GODataCache const *cache, unsigned int cache_def_num)
{
GsfXMLOut *xml;
int i, n;
char const *record_id;
char *name = g_strdup_printf ("pivotCacheDefinition%u.xml", cache_def_num);
GsfOutput *cache_def_part = gsf_outfile_new_child_full (state->pivotCache.dir, name, FALSE,
"content-type", "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml",
NULL);
char const *cache_def_id = gsf_outfile_open_pkg_relate (GSF_OUTFILE_OPEN_PKG (cache_def_part),
GSF_OUTFILE_OPEN_PKG (wb_part),
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition");
record_id = xlsx_write_pivot_cache_records (state, cache, cache_def_part, cache_def_num);
xml = gsf_xml_out_new (cache_def_part);
gsf_xml_out_start_element (xml, "pivotCacheDefinition");
gsf_xml_out_add_cstr_unchecked (xml, "xmlns", ns_ss);
gsf_xml_out_add_cstr_unchecked (xml, "xmlns:r", ns_rel);
gsf_xml_out_add_cstr (xml, "r:id", record_id);
if (cache->refreshed_by) gsf_xml_out_add_cstr (xml, "refreshedBy", cache->refreshed_by);
if (cache->refreshed_on) {
if (state->version == ECMA_376_2006)
gsf_xml_out_add_float (xml, "refreshedDate",
go_val_as_float (cache->refreshed_on), -1);
else {
GOFormat const *format = go_format_new_from_XL ("yyyy-mm-dd\"T\"hh:mm:ss");
gchar *date = format_value (format, cache->refreshed_on, NULL, -1, NULL);
gsf_xml_out_add_cstr_unchecked (xml, "refreshedDateIso", date);
g_free (date);
go_format_unref (format);
}
}
gsf_xml_out_add_int (xml, "createdVersion", cache->XL_created_ver);
gsf_xml_out_add_int (xml, "refreshedVersion", cache->XL_refresh_ver);
gsf_xml_out_add_uint (xml, "recordCount", go_data_cache_num_items (cache));
xlsx_add_bool (xml, "upgradeOnRefresh", cache->refresh_upgrades);
xlsx_write_pivot_cache_source (state, xml, cache);
gsf_xml_out_start_element (xml, "cacheFields");
n = go_data_cache_num_fields (cache);
gsf_xml_out_add_uint (xml, "count", n);
for (i = 0 ; i < n ; i++)
xlsx_write_pivot_cache_field (state, xml, go_data_cache_get_field (cache, i));
gsf_xml_out_end_element (xml); /* </cacheFields> */
gsf_xml_out_end_element (xml); /* </pivotCacheDefinition> */
g_object_unref (xml);
gsf_output_close (cache_def_part);
g_object_unref (cache_def_part);
g_free (name);
return cache_def_id;
}
static void close_gsf_handle(GsfOutput * output)
{
if (output)
{
gsf_output_close (output);
g_object_unref (G_OBJECT (output));
}
}
void s_XSL_FO_Listener::_handleDataItems(void)
{
const char * szName = NULL;
std::string mimeType;
const UT_ByteBuf * pByteBuf;
for (UT_uint32 k=0; (m_pDocument->enumDataItems(k, NULL, &szName, &pByteBuf, &mimeType)); k++)
{
UT_sint32 loc = -1;
for (UT_sint32 i = 0; i < m_utvDataIDs.getItemCount(); i++)
{
if(strcmp(reinterpret_cast<const char*>(m_utvDataIDs[i]), szName) == 0)
{
loc = i;
break;
}
}
if(loc > -1)
{
UT_UTF8String fname;
UT_UTF8String_sprintf(fname, "%s_data", m_pie->getFileName());
UT_go_directory_create(fname.utf8_str(), 0750, NULL);
if (mimeType == "image/svg+xml")
UT_UTF8String_sprintf(fname, "%s/%d.svg", fname.utf8_str(), loc);
else if (mimeType == "application/mathml+xml")
UT_UTF8String_sprintf(fname, "%s/%d.mathml", fname.utf8_str(), loc);
else // raster Image
{
const char * extension = "png";
if(mimeType == "image/jpeg") {
extension = "jpg";
}
char * temp = _stripSuffix(UT_go_basename(szName), '_');
char * fstripped = _stripSuffix(temp, '.');
UT_UTF8String_sprintf(fname, "%s/%s.%s", fname.utf8_str(), fstripped, extension);
FREEP(temp);
FREEP(fstripped);
}
GsfOutput *fp = UT_go_file_create (fname.utf8_str(), NULL);
if(!fp)
continue;
gsf_output_write(fp, pByteBuf->getLength(), (const guint8 *)pByteBuf->getPointer(0));
gsf_output_close(fp);
g_object_unref(fp);
}
}
return;
}
static char const *
xlsx_write_pivot_cache_records (XLSXWriteState *state, GODataCache const *cache,
GsfOutput *cache_def_part, unsigned int cache_records_num)
{
unsigned int i, j;
GsfXMLOut *xml;
char *name = g_strdup_printf ("pivotCacheRecords%u.xml", cache_records_num);
GsfOutput *record_part = gsf_outfile_new_child_full (state->pivotCache.dir, name, FALSE,
"content-type", "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml",
NULL);
char const *record_id = gsf_outfile_open_pkg_relate (GSF_OUTFILE_OPEN_PKG (record_part),
GSF_OUTFILE_OPEN_PKG (cache_def_part),
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheRecords");
xml = gsf_xml_out_new (record_part);
gsf_xml_out_start_element (xml, "pivotCacheRecords");
gsf_xml_out_add_cstr_unchecked (xml, "xmlns", ns_ss);
gsf_xml_out_add_cstr_unchecked (xml, "xmlns:r", ns_rel);
gsf_xml_out_add_int (xml, "count", go_data_cache_num_items (cache));
for (j = 0 ; j < go_data_cache_num_items (cache); j++) {
gsf_xml_out_start_element (xml, "r");
for (i = 0 ; i < go_data_cache_num_fields (cache); i++) {
GODataCacheField *field = go_data_cache_get_field (cache, i);
switch (go_data_cache_field_ref_type (field)) {
case GO_DATA_CACHE_FIELD_TYPE_INDEXED_I8 :
case GO_DATA_CACHE_FIELD_TYPE_INDEXED_I16 : /* fallthrough */
case GO_DATA_CACHE_FIELD_TYPE_INDEXED_I32 : /* fallthrough */
gsf_xml_out_start_element (xml, "x");
gsf_xml_out_add_int (xml, "v",
go_data_cache_get_index (cache, field, j));
gsf_xml_out_end_element (xml);
break;
case GO_DATA_CACHE_FIELD_TYPE_INLINE :
xlsx_write_pivot_val (state, xml,
go_data_cache_field_get_val (field, j));
break;
case GO_DATA_CACHE_FIELD_TYPE_NONE :
continue;
}
}
gsf_xml_out_end_element (xml); /* </r> */
}
gsf_xml_out_end_element (xml); /* </pivotCacheRecords> */
g_object_unref (xml);
gsf_output_close (record_part);
g_object_unref (record_part);
g_free (name);
return record_id;
}
/* Close all dirs, non-NULL on error.
*/
static void *
vips_gsf_tree_close( VipsGsfDirectory *tree )
{
vips_slist_map2( tree->children,
(VipsSListMap2Fn) vips_gsf_tree_close, NULL, NULL );
if( tree->out &&
!gsf_output_is_closed( tree->out ) &&
!gsf_output_close( tree->out ) ) {
vips_error( "vips_gsf", "%s", _( "unable to close stream" ) );
return( tree );
}
if( tree->container &&
!gsf_output_is_closed( tree->container ) &&
!gsf_output_close( tree->container ) ) {
vips_error( "vips_gsf", "%s", _( "unable to close stream" ) );
return( tree );
}
return( NULL );
}
static GsfInput *
make_local_copy (GFile *file, GInputStream *stream)
{
GsfOutput *out;
GsfInput *copy;
GFileInfo *info;
out = gsf_output_memory_new ();
while (1) {
guint8 buf[4096];
gssize nread;
nread = g_input_stream_read (stream, buf, sizeof(buf), NULL, NULL);
if (nread > 0) {
if (!gsf_output_write (out, nread, buf)) {
copy = NULL;
goto cleanup_and_exit;
}
}
else if (nread == 0)
break;
else {
copy = NULL;
goto cleanup_and_exit;
}
}
copy = gsf_input_memory_new_clone
(gsf_output_memory_get_bytes (GSF_OUTPUT_MEMORY (out)),
gsf_output_size (out));
if (copy != NULL) {
info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, NULL);
if (info) {
gsf_input_set_name (GSF_INPUT (copy), g_file_info_get_name (info));
g_object_unref (info);
}
}
cleanup_and_exit:
gsf_output_close (out);
g_object_unref (out);
g_input_stream_close (stream, NULL, NULL);
g_object_unref (stream);
set_name_from_file (copy, file);
return copy;
}
UT_Error IE_Exp_EPUB::writeContainer()
{
GsfOutput* metaInf = gsf_outfile_new_child(m_root, "META-INF", TRUE);
if (metaInf == NULL)
{
UT_DEBUGMSG(("Can`t create META-INF dir\n"));
return UT_ERROR;
}
GsfOutput* container = gsf_outfile_new_child(GSF_OUTFILE(metaInf),
"container.xml", FALSE);
if (container == NULL)
{
UT_DEBUGMSG(("Can`t create container.xml\n"));
gsf_output_close(metaInf);
return UT_ERROR;
}
GsfXMLOut * containerXml = gsf_xml_out_new(container);
// <container>
gsf_xml_out_start_element(containerXml, "container");
gsf_xml_out_add_cstr(containerXml, "version", "1.0");
gsf_xml_out_add_cstr(containerXml, "xmlns", OCF201_NAMESPACE);
// <rootfiles>
gsf_xml_out_start_element(containerXml, "rootfiles");
// <rootfile>
gsf_xml_out_start_element(containerXml, "rootfile");
gsf_xml_out_add_cstr(containerXml, "full-path", "OEBPS/book.opf");
gsf_xml_out_add_cstr(containerXml, "media-type", OPF_MIMETYPE);
// </rootfile>
gsf_xml_out_end_element(containerXml);
// </rootfiles>
gsf_xml_out_end_element(containerXml);
// </container>
gsf_xml_out_end_element(containerXml);
gsf_output_close(container);
gsf_output_close(metaInf);
return UT_OK;
}
static void
clone (GsfInput *input, GsfOutput *output)
{
guint8 const *data;
size_t len;
int i;
if (gsf_input_size (input) > 0) {
while ((len = gsf_input_remaining (input)) > 0) {
/* copy in odd sized chunks to exercise system */
if (len > 314)
len = 314;
if (NULL == (data = gsf_input_read (input, len, NULL))) {
g_warning ("error reading ?");
return;
}
if (!gsf_output_write (output, len, data)) {
g_warning ("error writing ?");
return;
}
}
}
/* See test-cp-msole.c for explanation how to distinct directories
* from regular files.
*/
if (GSF_IS_INFILE (input) &&
gsf_infile_num_children (GSF_INFILE (input)) > 0) {
GsfInfile *in = GSF_INFILE (input);
GsfOutfile *out = GSF_OUTFILE (output);
GsfInput *src;
GsfOutput *dst;
gboolean is_dir;
for (i = 0 ; i < gsf_infile_num_children (in) ; i++) {
src = gsf_infile_child_by_index (in, i);
is_dir = GSF_IS_INFILE (src) &&
gsf_infile_num_children (GSF_INFILE (src)) >= 0;
dst = gsf_outfile_new_child (out,
gsf_infile_name_by_index (in, i),
is_dir);
clone (src, dst);
}
}
gsf_output_close (output);
g_object_unref (G_OBJECT (output));
g_object_unref (G_OBJECT (input));
}
bool UT_ByteBuf::writeToURI(const char* pszURI) const
{
UT_ASSERT(pszURI && pszURI[0]);
GsfOutput *fp = UT_go_file_create(pszURI, NULL);
if (!fp)
return false;
gboolean res = gsf_output_write(fp, m_iSize, (guint8*)m_pBuf);
gsf_output_close(fp);
g_object_unref(G_OBJECT(fp));
return static_cast<bool>(res);
}
/* Close and unref everything, can't fail. Call vips_gsf_tree_close() to get
* an error return.
*/
static void *
vips_gsf_tree_free( VipsGsfDirectory *tree )
{
vips_slist_map2( tree->children,
(VipsSListMap2Fn) vips_gsf_tree_free, NULL, NULL );
g_slist_free( tree->children );
g_free( (char *) tree->name );
if( tree->out ) {
if( !gsf_output_is_closed( tree->out ) )
(void) gsf_output_close( tree->out );
g_object_unref( tree->out );
}
if( tree->container ) {
if( !gsf_output_is_closed( tree->container ) )
(void) gsf_output_close( tree->container );
g_object_unref( tree->container );
}
g_free( tree );
return( NULL );
}
static int
write_blank( VipsForeignSaveDz *dz )
{
VipsImage *x, *t;
int n;
VipsArea *ones;
double *d;
int i;
void *buf;
size_t len;
GsfOutput *out;
if( vips_black( &x, dz->tile_size, dz->tile_size, NULL ) )
return( -1 );
vips_area_get_data( (VipsArea *) dz->background, NULL, &n, NULL, NULL );
ones = vips_area_new_array( G_TYPE_DOUBLE, sizeof( double ), n );
d = (double *) vips_area_get_data( ones, NULL, NULL, NULL, NULL );
for( i = 0; i < n; i++ )
d[i] = 1.0;
if( vips_linear( x, &t,
d,
(double *) vips_area_get_data( (VipsArea *) dz->background,
NULL, NULL, NULL, NULL ),
n, NULL ) ) {
vips_area_unref( ones );
g_object_unref( x );
return( -1 );
}
vips_area_unref( ones );
g_object_unref( x );
x = t;
if( vips_pngsave_buffer( x, &buf, &len, NULL ) ) {
g_object_unref( x );
return( -1 );
}
g_object_unref( x );
out = vips_gsf_path( dz->tree, "blank.png", NULL );
gsf_output_write( out, len, buf );
gsf_output_close( out );
g_object_unref( out );
g_free( buf );
return( 0 );
}
static void
gsf_output_stdio_finalize (GObject *obj)
{
GsfOutput *output = (GsfOutput *)obj;
GsfOutputStdio *stdio = GSF_OUTPUT_STDIO (output);
if (!gsf_output_is_closed (output))
gsf_output_close (output);
g_free (stdio->real_filename);
stdio->real_filename = NULL;
g_free (stdio->temp_filename);
stdio->temp_filename = NULL;
parent_class->finalize (obj);
}
/* Add the filename under path to the gst_outfile. */
static void add_file_to_gst_outfile (GsfOutfile *out_file,
gchar *path,
const gchar *file_name)
{
GError *err = (GError *) NULL;
gchar *file_path = g_build_filename (path, file_name, NULL);
GsfInput *input = GSF_INPUT (gsf_input_stdio_new (file_path, &err));
GsfOutput *child = gsf_outfile_new_child (out_file, file_name, FALSE);
gsf_input_copy (input, child);
gsf_output_close (child);
g_object_unref (child);
g_object_unref (input);
g_free (file_path);
}
static void
soi_cb_save_as (SheetObject *so, SheetControl *sc)
{
WBCGtk *wbcg;
char *uri;
GsfOutput *output;
GSList *l = NULL;
GOImageFormat sel_fmt;
GOImageFormatInfo const *format_info;
GdkPixbuf *pixbuf = NULL;
GError *err = NULL;
SheetObjectImage *soi = SHEET_OBJECT_IMAGE (so);
g_return_if_fail (soi != NULL);
sel_fmt = go_image_get_format_from_name (soi->type);
if ((pixbuf = go_image_get_pixbuf (soi->image)) != NULL)
l = go_image_get_formats_with_pixbuf_saver ();
/* Move original format first in menu */
if (sel_fmt != GO_IMAGE_FORMAT_UNKNOWN) {
l = g_slist_remove (l, GUINT_TO_POINTER (sel_fmt));
l = g_slist_prepend (l, GUINT_TO_POINTER (sel_fmt));
}
wbcg = scg_wbcg (SHEET_CONTROL_GUI (sc));
uri = go_gui_get_image_save_info (wbcg_toplevel (wbcg), l, &sel_fmt, NULL);
if (!uri)
goto out;
output = go_file_create (uri, &err);
if (!output)
goto out;
format_info = go_image_get_format_info (sel_fmt);
sheet_object_write_image (so, (format_info? format_info->name: NULL), -1.0, output, &err);
gsf_output_close (output);
g_object_unref (output);
if (err != NULL)
go_cmd_context_error (GO_CMD_CONTEXT (wbcg), err);
out:
if (pixbuf)
g_object_unref (pixbuf);
g_free (uri);
g_slist_free (l);
}
UT_Error AbiCollabSessionManager::serializeDocument(const PD_Document* pDoc, std::string& document, bool encodeBase64)
{
UT_return_val_if_fail(pDoc, false);
// Don't put this auto-save in the most recent list.
XAP_App::getApp()->getPrefs()->setIgnoreNextRecent();
// maskExport();
GsfOutputMemory* sink = GSF_OUTPUT_MEMORY(gsf_output_memory_new());
GsfOutput* gzSink = gsf_output_gzip_new(GSF_OUTPUT(sink), NULL);
bool bAuthor = pDoc->isExportAuthorAtts();
const_cast<PD_Document *>(pDoc)->setExportAuthorAtts(true);
UT_Error result = const_cast<PD_Document*>(pDoc)->saveAs(GSF_OUTPUT(gzSink), IE_Exp::fileTypeForSuffix(".abw"), true);
const_cast<PD_Document *>(pDoc)->setExportAuthorAtts(bAuthor);
gsf_output_close(GSF_OUTPUT(gzSink));
// unmaskExport();
if (result == UT_OK)
{
guint32 size = gsf_output_size (GSF_OUTPUT(sink));
const guint8* zabwBuf = gsf_output_memory_get_bytes (sink);
if (encodeBase64)
{
// this would be more efficient if we had a GsfOutputBase64.. ah well, this will do for now
guint8* base64zabwBuf = gsf_base64_encode_simple(zabwBuf, size);
document += (char*)base64zabwBuf;
g_free(base64zabwBuf);
}
else
{
// just copy raw zipped data into string
document.resize( size );
memcpy( &document[0], zabwBuf, size );
}
}
else
{
UT_DEBUGMSG(("Failed to export! Handle this gracefully!\n"));
}
g_object_unref(G_OBJECT(gzSink));
g_object_unref(G_OBJECT(sink));
return result;
}
static int
test (char *argv[])
{
GsfInput *input;
GsfOutput *output;
GError *err = NULL;
int rval = 0;
input = gsf_input_stdio_new (argv[1], &err);
if (input == NULL) {
g_return_val_if_fail (err != NULL, 1);
g_warning ("'%s' error: %s\n", 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\n", argv[2], err->message);
g_error_free (err);
g_object_unref (G_OBJECT (input));
return 1;
}
if (gsf_input_copy (input, output) == FALSE) {
rval = 1;
err = (GError*) gsf_output_error (output);
if (err != NULL) {
g_warning ("'%s' error: %s\n", argv[2], err->message);
}
}
g_object_unref (G_OBJECT (input));
gsf_output_close (output);
g_object_unref (G_OBJECT (output));
return rval;
}
uint32_t FileWriterI::fileClose(int32_t handler) {
if (handler >=0 && handler < (int32_t)openFileHandler.size()) {
GsfOutput * output = openFileHandler[handler];
gsf_output_close (output);
g_object_unref (G_OBJECT (output));
openFileHandler[handler] = NULL;
DEBUG << "ops::msole::FileWriterI::fileClose() : file closed";
return ops::RET_OK;
} else {
ERROR << "ops::msole::FileWriterI::fileClose() : unknown handler";
return ops::RET_ERR;
}
}
UT_Error IE_Imp_EPUB::uncompress()
{
m_tmpDir = UT_go_filename_to_uri(g_get_tmp_dir());
m_tmpDir += G_DIR_SEPARATOR_S;
m_tmpDir += getDoc()->getDocUUIDString();
if (!UT_go_directory_create(m_tmpDir.c_str(), 0644, NULL))
{
UT_DEBUGMSG(("Can`t create temporary directory\n"));
return UT_ERROR;
}
GsfInput *opsDirInput = gsf_infile_child_by_name(m_epub,
m_opsDir.c_str());
UT_DEBUGMSG(("Child count : %d", gsf_infile_num_children(m_epub)));
if (opsDirInput == NULL)
{
UT_DEBUGMSG(("Failed to open OPS dir\n"));
return UT_ERROR;
}
for (std::map<std::string, std::string>::iterator i =
m_manifestItems.begin(); i != m_manifestItems.end(); i++)
{
gchar *itemFileName = UT_go_filename_from_uri(
(m_tmpDir + G_DIR_SEPARATOR_S + (*i).second).c_str());
gchar** aname =
g_strsplit((*i).second.c_str(), G_DIR_SEPARATOR_S, 0);
GsfInput* itemInput = gsf_infile_child_by_aname(
GSF_INFILE(opsDirInput), (const char**) aname);
GsfOutput* itemOutput = createFileByPath(itemFileName);
gsf_input_seek(itemInput, 0, G_SEEK_SET);
gsf_input_copy(itemInput, itemOutput);
g_strfreev(aname);
g_free(itemFileName);
g_object_unref(G_OBJECT(itemInput));
gsf_output_close(itemOutput);
}
g_object_unref(G_OBJECT(opsDirInput));
return UT_OK;
}
static int
write_properties( VipsForeignSaveDz *dz )
{
GsfOutput *out;
out = vips_gsf_path( dz->tree, "ImageProperties.xml", NULL );
gsf_output_printf( out, "<IMAGE_PROPERTIES "
"WIDTH=\"%d\" HEIGHT=\"%d\" NUMTILES=\"%d\" "
"NUMIMAGES=\"1\" VERSION=\"1.8\" TILESIZE=\"%d\" />\n",
dz->layer->width,
dz->layer->height,
dz->tile_count,
dz->tile_size );
(void) gsf_output_close( out );
g_object_unref( out );
return( 0 );
}
static void
gsf_output_dispose (GObject *obj)
{
GsfOutput *output = GSF_OUTPUT (obj);
if (!output->is_closed) {
/* g_warning ("Disposing of an unclosed stream"); */
gsf_output_close (output);
}
gsf_output_set_container (output, NULL);
gsf_output_set_name (output, NULL);
g_free (output->printf_buf);
output->printf_buf = NULL;
g_clear_error (&output->err);
parent_class->dispose (obj);
}
ULONG STDMETHODCALLTYPE
OMGSFIStorage::Release(void)
{
TRACE("OMGSFIStorage::Release");
ULONG result = --_referenceCount;
if (_referenceCount == 0)
{
if (_storage != 0)
{
if (GSF_IS_OUTPUT(_storage))
{
gsf_output_close (GSF_OUTPUT(_storage));
}
g_object_unref (G_OBJECT(_storage));
_storage = 0;
}
delete this;
}
return result;
}
