Add libgsf-1 bindings, patch by Michael Lawrence, fixes bug 455141
authorJürg Billeter <j@bitron.ch>
Mon, 23 Jun 2008 19:01:02 +0000 (19:01 +0000)
committerJürg Billeter <juergbi@src.gnome.org>
Mon, 23 Jun 2008 19:01:02 +0000 (19:01 +0000)
2008-06-23  Jürg Billeter  <j@bitron.ch>

* vapi/Makefile.am:
* vapi/libgsf-1.deps:
* vapi/libgsf-1.vapi:
* vapi/packages/libgsf-1/:

Add libgsf-1 bindings, patch by Michael Lawrence, fixes bug 455141

svn path=/trunk/; revision=1641

12 files changed:
ChangeLog
vapi/Makefile.am
vapi/libgsf-1.deps [new file with mode: 0644]
vapi/libgsf-1.vapi [new file with mode: 0644]
vapi/packages/libgsf-1/libgsf-1-custom.vala [new file with mode: 0644]
vapi/packages/libgsf-1/libgsf-1.deps [new file with mode: 0644]
vapi/packages/libgsf-1/libgsf-1.excludes [new file with mode: 0644]
vapi/packages/libgsf-1/libgsf-1.files [new file with mode: 0644]
vapi/packages/libgsf-1/libgsf-1.gi [new file with mode: 0644]
vapi/packages/libgsf-1/libgsf-1.metadata [new file with mode: 0644]
vapi/packages/libgsf-1/libgsf-1.namespace [new file with mode: 0644]
vapi/poppler-glib.deps

index f32ae3c..23750f5 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,14 @@
 2008-06-23  Jürg Billeter  <j@bitron.ch>
 
+       * vapi/Makefile.am:
+       * vapi/libgsf-1.deps:
+       * vapi/libgsf-1.vapi:
+       * vapi/packages/libgsf-1/:
+
+       Add libgsf-1 bindings, patch by Michael Lawrence, fixes bug 455141
+
+2008-06-23  Jürg Billeter  <j@bitron.ch>
+
        * gobject/valaccodeassignmentbinding.vala:
 
        Support disconnecting from detailed signals
index 7e54c7a..0c67957 100644 (file)
@@ -90,6 +90,8 @@ dist_vapi_DATA = \
        libgnome-menu.vapi \
        libgnomeui-2.0.deps \
        libgnomeui-2.0.vapi \
+       libgsf-1.deps \
+       libgsf-1.vapi \
        libnotify.deps \
        libnotify.vapi \
        liboobs-1.vapi \
diff --git a/vapi/libgsf-1.deps b/vapi/libgsf-1.deps
new file mode 100644 (file)
index 0000000..e17ccd5
--- /dev/null
@@ -0,0 +1 @@
+libxml-2.0
\ No newline at end of file
diff --git a/vapi/libgsf-1.vapi b/vapi/libgsf-1.vapi
new file mode 100644 (file)
index 0000000..95372f4
--- /dev/null
@@ -0,0 +1,680 @@
+/* libgsf-1.vapi generated by lt-vapigen, do not modify. */
+
+[CCode (cprefix = "Gsf", lower_case_cprefix = "gsf_")]
+namespace Gsf {
+       [CCode (cprefix = "GSF_CLIP_FORMAT_", has_type_id = "0", cheader_filename = "gsf/gsf-clip-data.h")]
+       public enum ClipFormat {
+               WINDOWS_CLIPBOARD,
+               MACINTOSH_CLIPBOARD,
+               GUID,
+               NO_DATA,
+               CLIPBOARD_FORMAT_NAME,
+               UNKNOWN
+       }
+       [CCode (cprefix = "GSF_CLIP_FORMAT_WINDOWS_", has_type_id = "0", cheader_filename = "gsf/gsf-clip-data.h")]
+       public enum ClipFormatWindows {
+               ERROR,
+               UNKNOWN,
+               METAFILE,
+               DIB,
+               ENHANCED_METAFILE
+       }
+       [CCode (cprefix = "GSF_OUTPUT_CSV_QUOTING_MODE_", cheader_filename = "gsf/gsf-output-csv.h")]
+       public enum OutputCsvQuotingMode {
+               NEVER,
+               AUTO,
+               ALWAYS
+       }
+       [CCode (cprefix = "GSF_XML_", has_type_id = "0", cheader_filename = "gsf/gsf-libxml.h")]
+       public enum XMLContent {
+               NO_CONTENT,
+               CONTENT,
+               SHARED_CONTENT
+       }
+       [CCode (cprefix = "GSF_ZIP_", has_type_id = "0", cheader_filename = "gsf/gsf-outfile-zip.h")]
+       public enum ZipCompressionMethod {
+               STORED,
+               SHRUNK,
+               REDUCEDx1,
+               REDUCEDx2,
+               REDUCEDx3,
+               REDUCEDx4,
+               IMPLODED,
+               TOKENIZED,
+               DEFLATED,
+               DEFLATED_BETTER,
+               IMPLODED_BETTER
+       }
+       [CCode (cprefix = "GSF_ERROR_", cheader_filename = "gsf/gsf-utils.h")]
+       public errordomain Error {
+               OUT_OF_MEMORY,
+               INVALID_DATA,
+       }
+       [CCode (cheader_filename = "gsf/gsf-input-impl.h")]
+       public class Input : GLib.Object {
+               public Gsf.off_t cur_offset;
+               public static Gsf.Input uncompress (Gsf.Input# src);
+               public Input ();
+               public weak Gsf.Infile? container ();
+               public bool copy (Gsf.Output output);
+               public void dump (bool dump_as_hex);
+               public Gsf.Input dup () throws GLib.Error;
+               public bool eof ();
+               public static GLib.Quark error ();
+               public static GLib.Quark error_id ();
+               public static Gsf.Input mmap_new (string filename) throws GLib.Error;
+               public weak string? name ();
+               [NoArrayLength]
+               public weak uchar[] read (ulong num_bytes, uchar[] optional_buffer);
+               public Gsf.off_t remaining ();
+               public bool seek (Gsf.off_t offset, GLib.SeekType whence);
+               public bool seek_emulate (Gsf.off_t pos);
+               public bool set_container (Gsf.Infile? container);
+               public bool set_name (string? name);
+               public bool set_name_from_filename (string filename);
+               public bool set_size (Gsf.off_t size);
+               public weak Gsf.Input? sibling (string name) throws GLib.Error;
+               public Gsf.off_t size ();
+               public Gsf.off_t tell ();
+               [NoWrapper]
+               public virtual Gsf.Input Dup () throws GLib.Error;
+               [NoWrapper]
+               public virtual Gsf.Input OpenSibling (string path) throws GLib.Error;
+               [NoWrapper]
+               [NoArrayLength]
+               public virtual weak uchar[] Read (ulong num_bytes, uchar[] optional_buffer);
+               [NoWrapper]
+               public virtual bool Seek (Gsf.off_t offset, GLib.SeekType whence);
+               [NoAccessorMethod]
+               public int64 position { get; }
+       }
+       [Compact]
+       [CCode (cheader_filename = "gsf/gsf-doc-meta-data.h")]
+       public class DocProp {
+               public void dump ();
+               public weak string? get_link ();
+               public weak string get_name ();
+               public weak GLib.Value? get_val ();
+               public DocProp (string# name);
+               public void set_link (string# link);
+               public void set_val (GLib.Value# val);
+               public GLib.Value swap_val (GLib.Value val);
+       }
+       [Compact]
+       [CCode (cheader_filename = "gsf/gsf-open-pkg-utils.h")]
+       public class OpenPkgRel {
+               public weak string get_target ();
+               public bool is_extern ();
+       }
+       [Compact]
+       [CCode (cheader_filename = "gsf/gsf-open-pkg-utils.h")]
+       public class OpenPkgRels {
+       }
+       [Compact]
+       [CCode (cheader_filename = "gsf/gsf-libxml.h")]
+       public class XMLBlob {
+       }
+       [Compact]
+       [CCode (cheader_filename = "gsf/gsf-libxml.h")]
+       public class XMLIn {
+               public void* user_state;
+               public weak GLib.StringBuilder content;
+               public weak Gsf.XMLInDoc doc;
+               public weak Gsf.XMLInNode node;
+               public weak GLib.SList node_stack;
+               public weak string check_ns (string str, uint ns_id);
+               public weak Gsf.Input get_input ();
+               public bool namecmp (string str, uint ns_id, string name);
+               public void push_state (Gsf.XMLInDoc doc, void* new_state, Gsf.XMLInExtDtor dtor, string[] attrs);
+       }
+       [Compact]
+       [CCode (cheader_filename = "gsf/gsf-libxml.h")]
+       public class XMLInDoc {
+               public XMLInDoc (Gsf.XMLInNode[] nodes, Gsf.XMLInNS ns);
+               public bool parse (Gsf.Input input, void* user_state);
+               public void set_unknown_handler (Gsf.XMLInUnknownFunc handler);
+       }
+       [Compact]
+       [CCode (cheader_filename = "gsf/gsf-libxml.h")]
+       public class XMLInNS {
+               public weak string uri;
+               public uint ns_id;
+       }
+       [Compact]
+       [CCode (cheader_filename = "gsf/gsf-libxml.h")]
+       public class XMLInNode {
+               public weak string id;
+               public int ns_id;
+               public weak string name;
+               public weak string parent_id;
+               public weak GLib.Callback start;
+               public weak GLib.Callback end;
+               public void* user_data;
+               public Gsf.XMLContent has_content;
+               public uint check_children_for_ns;
+               public uint share_children_with_parent;
+       }
+       [Compact]
+       [CCode (copy_function = "gsf_timestamp_copy", cheader_filename = "gsf/gsf-timestamp.h")]
+       public class Timestamp {
+               public GLib.Date date;
+               public long seconds;
+               public weak GLib.StringBuilder time_zone;
+               public uint timet;
+               public string as_string ();
+               public Gsf.Timestamp copy ();
+               public bool equal (Gsf.Timestamp b);
+               public uint hash ();
+               public static int parse (string spec, Gsf.Timestamp stamp);
+       }
+       [CCode (cheader_filename = "gsf/gsf-blob.h")]
+       public class Blob : GLib.Object {
+               public ulong get_size ();
+               public Blob (ulong size, void* data_to_copy) throws GLib.Error;
+               public void* peek_data ();
+       }
+       [CCode (cheader_filename = "gsf/gsf-clip-data.h")]
+       public class ClipData : GLib.Object {
+               public weak Gsf.Blob get_data_blob ();
+               public Gsf.ClipFormat get_format ();
+               public Gsf.ClipFormatWindows get_windows_clipboard_format () throws GLib.Error;
+               public ClipData (Gsf.ClipFormat format, Gsf.Blob data_blob);
+               public void* peek_real_data (ulong ret_size) throws GLib.Error;
+       }
+       [CCode (cheader_filename = "gsf/gsf-doc-meta-data.h")]
+       public class DocMetaData : GLib.Object {
+               public void @foreach (GLib.HFunc func);
+               public void insert (string name, GLib.Value value);
+               public weak Gsf.DocProp? lookup (string name);
+               public DocMetaData ();
+               public void remove (string name);
+               public ulong size ();
+               public weak Gsf.DocProp? steal (string name);
+               public void store (Gsf.DocProp prop);
+       }
+       [CCode (cheader_filename = "gsf/gsf-docprop-vector.h")]
+       public class DocPropVector : GLib.Object {
+               [CCode (cname = "gsf_docprop_vector_append")]
+               public void append (GLib.Value value);
+               [CCode (cname = "gsf_docprop_vector_as_string")]
+               public string as_string ();
+               [CCode (cname = "gsf_docprop_vector_new")]
+               public DocPropVector ();
+       }
+       [CCode (cheader_filename = "gsf/gsf-infile-impl.h")]
+       public class Infile : Gsf.Input {
+               public weak Gsf.Input? child_by_vname (string name);
+               public virtual weak Gsf.Input? child_by_index (int i);
+               public virtual weak Gsf.Input? child_by_name (string name);
+               public virtual weak string? name_by_index (int i);
+               public virtual int num_children ();
+       }
+       [CCode (cheader_filename = "gsf/gsf-infile-msole.h")]
+       public class InfileMSOle : Gsf.Infile {
+               [CCode (cname = "gsf_infile_msole_get_class_id")]
+               public bool get_class_id (uchar res);
+               [CCode (cname = "gsf_infile_msole_new")]
+               public InfileMSOle (Gsf.Input source) throws GLib.Error;
+       }
+       [CCode (cheader_filename = "gsf/gsf-infile-msvba.h")]
+       public class InfileMSVBA : Gsf.Infile {
+               public InfileMSVBA (Gsf.Infile source) throws GLib.Error;
+       }
+       [CCode (cheader_filename = "gsf/gsf-infile-stdio.h")]
+       public class InfileStdio : Gsf.Infile {
+               public InfileStdio (string root) throws GLib.Error;
+       }
+       [CCode (cheader_filename = "gsf/gsf-infile-zip.h")]
+       public class InfileZip : Gsf.Infile {
+               public InfileZip (Gsf.Input source) throws GLib.Error;
+               [NoAccessorMethod]
+               public int compression_level { get; }
+               [NoAccessorMethod]
+               public Gsf.InfileZip internal_parent { construct; }
+               [NoAccessorMethod]
+               public Gsf.Input source { get; construct; }
+       }
+       [CCode (cheader_filename = "gsf/gsf-input-gzip.h")]
+       public class InputGZip : Gsf.Input {
+               public InputGZip (Gsf.Input source) throws GLib.Error;
+               [NoAccessorMethod]
+               public bool raw { get; construct; }
+               [NoAccessorMethod]
+               public Gsf.Input source { get; construct; }
+               [NoAccessorMethod]
+               public int64 uncompressed_size { get; construct; }
+       }
+       [CCode (cheader_filename = "gsf/gsf-input-http.h")]
+       public class InputHTTP : Gsf.Input {
+               public weak string get_content_type ();
+               public weak string get_url ();
+               public InputHTTP (string url) throws GLib.Error;
+               [NoAccessorMethod]
+               public string content_type { get; construct; }
+               [NoAccessorMethod]
+               public string url { get; construct; }
+       }
+       [CCode (cheader_filename = "gsf/gsf-input-memory.h")]
+       public class InputMemory : Gsf.Input {
+               public InputMemory (uchar buf, Gsf.off_t length, bool needs_free);
+               public InputMemory.clone (uchar buf, Gsf.off_t length);
+               public InputMemory.from_bzip (Gsf.Input source) throws GLib.Error;
+               public InputMemory.from_iochannel (GLib.IOChannel channel) throws GLib.Error;
+       }
+       [CCode (cheader_filename = "gsf/gsf-input-proxy.h")]
+       public class InputProxy : Gsf.Input {
+               public InputProxy (Gsf.Input source);
+               public InputProxy.section (Gsf.Input source, Gsf.off_t offset, Gsf.off_t size);
+       }
+       [CCode (cheader_filename = "gsf/gsf-input-stdio.h")]
+       public class InputStdio : Gsf.Input {
+               public InputStdio (string filename) throws GLib.Error;
+       }
+       [CCode (cheader_filename = "gsf/gsf-input-textline.h")]
+       public class InputTextline : Gsf.Input {
+               [NoArrayLength]
+               public weak uint[] ascii_gets ();
+               public InputTextline (Gsf.Input source);
+               [NoArrayLength]
+               public weak uchar[] utf8_gets ();
+       }
+       [CCode (cheader_filename = "gsf/gsf-outfile-impl.h")]
+       public class Outfile : Gsf.Output {
+               public Outfile.child_full (Gsf.Outfile outfile, string name, bool is_dir, ...);
+               public Outfile.child (Gsf.Outfile outfile, string name, bool is_dir);
+       }
+       [CCode (cheader_filename = "gsf/gsf-outfile-msole.h")]
+       public class OutfileMSOle : Gsf.Outfile {
+               [CCode (cname = "gsf_outfile_msole_new")]
+               public OutfileMSOle (Gsf.Output sink);
+               [CCode (cname = "gsf_outfile_msole_new_full")]
+               public OutfileMSOle.full (Gsf.Output sink, uint bb_size, uint sb_size);
+               [CCode (cname = "gsf_outfile_msole_set_class_id")]
+               public bool set_class_id (uchar clsid);
+       }
+       [CCode (cheader_filename = "gsf/gsf-open-pkg-utils.h")]
+       public class OutfileOpenPkg : Gsf.Outfile {
+               public weak string add_extern_rel (string target, string content_type);
+               public static Gsf.Output add_rel (Gsf.Outfile dir, string name, string content_type, Gsf.Outfile parent, string type);
+               public OutfileOpenPkg (Gsf.Outfile sink);
+               public weak string relate (Gsf.OutfileOpenPkg parent, string type);
+               public void set_content_type (string content_type);
+               public void set_sink (Gsf.Output sink);
+               [NoAccessorMethod]
+               public string content_type { get; construct; }
+               [NoAccessorMethod]
+               public bool is_dir { get; construct; }
+               [NoAccessorMethod]
+               public Gsf.Outfile sink { get; construct; }
+       }
+       [CCode (cheader_filename = "gsf/gsf-outfile-stdio.h")]
+       public class OutfileStdio : Gsf.Outfile {
+               public OutfileStdio (string root) throws GLib.Error;
+               public OutfileStdio.full (string root, ...) throws GLib.Error;
+       }
+       [CCode (cheader_filename = "gsf/gsf-outfile-zip.h")]
+       public class OutfileZip : Gsf.Outfile {
+               public OutfileZip (Gsf.Output sink) throws GLib.Error;
+               public bool set_compression_method (Gsf.ZipCompressionMethod method);
+               [NoAccessorMethod]
+               public int compression_level { get; construct; }
+               [NoAccessorMethod]
+               public string entry_name { get; construct; }
+               [NoAccessorMethod]
+               public Gsf.Output sink { get; construct; }
+       }
+       [CCode (cheader_filename = "gsf/gsf-output-impl.h")]
+       public class Output : GLib.Object {
+               public Gsf.off_t cur_size;
+               public Gsf.off_t cur_offset;
+               public weak GLib.Object wrapped_by;
+               public weak GLib.Error err;
+               public weak string printf_buf;
+               public int printf_buf_size;
+               public bool close ();
+               public weak Gsf.Outfile? container ();
+               public weak GLib.Error error ();
+               public static GLib.Quark error_id ();
+               public bool is_closed ();
+               public weak string? name ();
+               public bool printf (string format, ...);
+               public bool puts (string line);
+               public bool seek (Gsf.off_t offset, GLib.SeekType whence);
+               public bool set_container (Gsf.Outfile? container);
+               public bool set_error (int code, string format);
+               public bool set_name (string? name);
+               public bool set_name_from_filename (string filename);
+               public Gsf.off_t size ();
+               public Gsf.off_t tell ();
+               public static bool unwrap (GLib.Object wrapper, Gsf.Output wrapee);
+               public static bool wrap (GLib.Object wrapper, Gsf.Output wrapee);
+               public bool write (ulong num_bytes, uchar[] data);
+               [NoWrapper]
+               public virtual bool Close ();
+               [NoWrapper]
+               public virtual bool Seek (Gsf.off_t offset, GLib.SeekType whence);
+               [NoWrapper]
+               public virtual bool Write (ulong num_bytes, uchar[] data);
+               [NoAccessorMethod]
+               public int64 position { get; }
+       }
+       [CCode (cheader_filename = "gsf/gsf-output-bzip.h")]
+       public class OutputBzip : Gsf.Output {
+               public OutputBzip (Gsf.Output sink) throws GLib.Error;
+       }
+       [CCode (cheader_filename = "gsf/gsf-output-csv.h")]
+       public class OutputCsv : Gsf.Output {
+               public ulong quote_len;
+               public ulong eol_len;
+               public ulong separator_len;
+               public bool fields_on_line;
+               public weak GLib.StringBuilder buf;
+               public bool write_eol ();
+               public bool write_field (string field, ulong len);
+               [NoAccessorMethod]
+               public string eol { get; set construct; }
+               [NoAccessorMethod]
+               public string quote { get; set construct; }
+               [NoAccessorMethod]
+               public Gsf.OutputCsvQuotingMode quoting_mode { get; set construct; }
+               [NoAccessorMethod]
+               public bool quoting_on_whitespace { get; set; }
+               [NoAccessorMethod]
+               public string quoting_triggers { get; set; }
+               [NoAccessorMethod]
+               public string separator { get; set construct; }
+               [NoAccessorMethod]
+               public Gsf.Output sink { get; set; }
+       }
+       [CCode (cheader_filename = "gsf/gsf-output-gzip.h")]
+       public class OutputGZip : Gsf.Output {
+               public OutputGZip (Gsf.Output sink) throws GLib.Error;
+               [NoAccessorMethod]
+               public bool raw { get; construct; }
+               [NoAccessorMethod]
+               public Gsf.Output sink { get; construct; }
+       }
+       [CCode (cheader_filename = "gsf/gsf-output-iochannel.h")]
+       public class OutputIOChannel : Gsf.Output {
+               [CCode (cname = "gsf_output_iochannel_new")]
+               public OutputIOChannel (GLib.IOChannel channel);
+       }
+       [CCode (cheader_filename = "gsf/gsf-output-iconv.h")]
+       public class OutputIconv : Gsf.Output {
+               public OutputIconv (Gsf.Output sink, string dst, string src);
+               [NoAccessorMethod]
+               public string fallback { get; set; }
+               [NoAccessorMethod]
+               public string input_charset { get; construct; }
+               [NoAccessorMethod]
+               public string output_charset { get; construct; }
+               [NoAccessorMethod]
+               public Gsf.Output sink { get; construct; }
+       }
+       [CCode (cheader_filename = "gsf/gsf-output-memory.h")]
+       public class OutputMemory : Gsf.Output {
+               [NoArrayLength]
+               public weak uchar[] get_bytes ();
+               public OutputMemory ();
+       }
+       [CCode (cheader_filename = "gsf/gsf-output-stdio.h")]
+       public class OutputStdio : Gsf.Output {
+               public OutputStdio (string filename) throws GLib.Error;
+               public OutputStdio.full (string filename, ...) throws GLib.Error;
+       }
+       [CCode (cheader_filename = "gsf/gsf-structured-blob.h")]
+       public class StructuredBlob : Gsf.Infile {
+               public static Gsf.StructuredBlob read (Gsf.Input input);
+               public bool write (Gsf.Outfile container);
+       }
+       [CCode (cheader_filename = "gsf/gsf-libxml.h")]
+       public class XMLOut : GLib.Object {
+               public void add_base64 (string id, uchar data, uint len);
+               public void add_bool (string id, bool val);
+               public void add_color (string id, uint r, uint g, uint b);
+               public void add_cstr (string id, string val_utf8);
+               public void add_cstr_unchecked (string id, string val_utf8);
+               public void add_enum (string id, GLib.Type etype, int val);
+               public void add_float (string id, double val, int precision);
+               public void add_gvalue (string id, GLib.Value val);
+               public void add_int (string id, int val);
+               public void add_uint (string id, uint val);
+               public weak string end_element ();
+               public weak Gsf.Output get_output ();
+               public XMLOut (Gsf.Output output);
+               public void set_doc_type (string type);
+               public void simple_element (string id, string content);
+               public void simple_float_element (string id, double val, int precision);
+               public void simple_int_element (string id, int val);
+               public void start_element (string id);
+               [NoAccessorMethod]
+               public bool pretty_print { get; set; }
+       }
+       [CCode (cheader_filename = "gsf/gsf.h")]
+       [SimpleType]
+       public struct off_t : int64 {
+       }
+       [CCode (cheader_filename = "gsf/gsf-libxml.h")]
+       public static delegate void XMLInExtDtor (Gsf.XMLIn xin, void* old_state);
+       [CCode (cheader_filename = "gsf/gsf-libxml.h")]
+       public static delegate bool XMLInUnknownFunc (Gsf.XMLIn xin, string elem, out weak string attrs);
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_BYTE_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_CASE_SENSITIVE;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_CATEGORY;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_CELL_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_CHARACTER_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_CODEPAGE;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_COMPANY;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_CREATOR;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_DATE_CREATED;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_DATE_MODIFIED;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_DESCRIPTION;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_DICTIONARY;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_DOCUMENT_PARTS;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_EDITING_DURATION;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_GENERATOR;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_HEADING_PAIRS;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_HIDDEN_SLIDE_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_IMAGE_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_INITIAL_CREATOR;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_KEYWORD;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_KEYWORDS;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_LANGUAGE;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_LAST_PRINTED;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_LAST_SAVED_BY;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_LINE_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_LINKS_DIRTY;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_LOCALE_SYSTEM_DEFAULT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_MANAGER;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_MM_CLIP_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_MSOLE_UNKNOWN_17;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_MSOLE_UNKNOWN_18;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_MSOLE_UNKNOWN_19;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_MSOLE_UNKNOWN_20;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_MSOLE_UNKNOWN_21;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_MSOLE_UNKNOWN_22;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_MSOLE_UNKNOWN_23;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_NOTE_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_OBJECT_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_PAGE_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_PARAGRAPH_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_PRESENTATION_FORMAT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_PRINTED_BY;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_PRINT_DATE;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_REVISION_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_SCALE;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_SECURITY;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_SLIDE_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_SPREADSHEET_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_SUBJECT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_TABLE_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_TEMPLATE;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_THUMBNAIL;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_TITLE;
+       [CCode (cheader_filename = "gsf/gsf-meta-names.h")]
+       public const string META_NAME_WORD_COUNT;
+       [CCode (cheader_filename = "gsf/gsf-outfile-ole.h")]
+       public const int OLE_DEFAULT_BB_SHIFT;
+       [CCode (cheader_filename = "gsf/gsf-outfile-ole.h")]
+       public const int OLE_DEFAULT_SB_SHIFT;
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static ulong base64_decode_simple (uchar[] data, ulong len);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static ulong base64_decode_step (uchar[] @in, ulong len, uchar[] @out, out int state, out uint save);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static ulong base64_encode_close (uchar[] @in, ulong inlen, bool break_lines, uchar[] @out, out int state, out uint save);
+       [NoArrayLength]
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static weak uchar[] base64_encode_simple (uchar[] data, ulong len);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static ulong base64_encode_step (uchar[] @in, ulong len, bool break_lines, uchar[] @out, out int state, out uint save);
+       [CCode (cheader_filename = "gsf/gsf-doc-meta-data.h")]
+       public static void doc_meta_dump (Gsf.DocMetaData meta);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static GLib.Quark error_quark ();
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static weak string extension_pointer (string path);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static string filename_to_utf8 (string filename, bool quoted);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static void iconv_close (GLib.IConv handle);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static void init ();
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static void init_dynamic (GLib.TypeModule module);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static double le_get_double (void* p);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static float le_get_float (void* p);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static uint64 le_get_guint64 (void* p);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static void le_set_double (void* p, double d);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static void le_set_float (void* p, float f);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static void mem_dump (uchar[] ptr, ulong len);
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static uint msole_codepage_to_lid (int codepage);
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static GLib.IConv msole_iconv_open_codepage_for_export (int codepage_to);
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static GLib.IConv msole_iconv_open_codepage_for_import (string to, int codepage);
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static GLib.IConv msole_iconv_open_codepages_for_export (int codepage_to, string from);
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static GLib.IConv msole_iconv_open_for_export ();
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static GLib.IConv msole_iconv_open_for_import (int codepage);
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static int msole_iconv_win_codepage ();
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static weak GLib.ByteArray msole_inflate (Gsf.Input input, Gsf.off_t offset);
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static weak string msole_language_for_lid (uint lid);
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static uint msole_lid_for_language (string lang);
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static int msole_lid_to_codepage (uint lid);
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static weak string msole_lid_to_codepage_str (uint lid);
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static weak GLib.Error msole_metadata_read (Gsf.Input @in, Gsf.DocMetaData accum);
+       [CCode (cheader_filename = "gsf/gsf-msole-utils.h")]
+       public static bool msole_metadata_write (Gsf.Output @out, Gsf.DocMetaData meta_data, bool doc_not_component);
+       [CCode (cheader_filename = "gsf/gsf-open-pkg-utils.h")]
+       public static int open_pkg_error_id ();
+       [CCode (cheader_filename = "gsf/gsf-open-pkg-utils.h")]
+       public static Gsf.Input open_pkg_get_rel_by_id (Gsf.Input @in, string id);
+       [CCode (cheader_filename = "gsf/gsf-open-pkg-utils.h")]
+       public static Gsf.Input open_pkg_get_rel_by_type (Gsf.Input @in, string type);
+       [CCode (cheader_filename = "gsf/gsf-open-pkg-utils.h")]
+       public static weak Gsf.OpenPkgRel open_pkg_lookup_rel_by_id (Gsf.Input @in, string id);
+       [CCode (cheader_filename = "gsf/gsf-open-pkg-utils.h")]
+       public static weak Gsf.OpenPkgRel open_pkg_lookup_rel_by_type (Gsf.Input @in, string type);
+       [CCode (cheader_filename = "gsf/gsf-open-pkg-utils.h")]
+       public static Gsf.Input open_pkg_open_rel_by_id (Gsf.Input @in, string id) throws GLib.Error;
+       [CCode (cheader_filename = "gsf/gsf-open-pkg-utils.h")]
+       public static Gsf.Input open_pkg_open_rel_by_type (Gsf.Input @in, string type) throws GLib.Error;
+       [CCode (cheader_filename = "gsf/gsf-open-pkg-utils.h")]
+       public static weak GLib.Error open_pkg_parse_rel_by_id (Gsf.XMLIn xin, string id, Gsf.XMLInNode dtd, Gsf.XMLInNS ns);
+       [CCode (cheader_filename = "gsf/gsf-opendoc-utils.h")]
+       public static weak GLib.Error opendoc_metadata_read (Gsf.Input input, Gsf.DocMetaData md);
+       [CCode (cheader_filename = "gsf/gsf-opendoc-utils.h")]
+       public static void opendoc_metadata_subtree (Gsf.XMLIn doc, Gsf.DocMetaData md);
+       [CCode (cheader_filename = "gsf/gsf-opendoc-utils.h")]
+       public static bool opendoc_metadata_write (Gsf.XMLOut output, Gsf.DocMetaData md);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static void property_settings_collect (GLib.Type object_type, GLib.Parameter[] p_params, ref ulong p_n_params, ...);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static void property_settings_free (GLib.Parameter[] params);
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static void shutdown ();
+       [CCode (cheader_filename = "gsf/gsf-utils.h")]
+       public static void shutdown_dynamic (GLib.TypeModule module);
+       [CCode (cheader_filename = "gsf/gsf-docprop-vector.h")]
+       public static GLib.ValueArray value_get_docprop_varray (GLib.Value value);
+       [CCode (cheader_filename = "gsf/gsf-docprop-vector.h")]
+       public static weak Gsf.DocPropVector value_get_docprop_vector (GLib.Value value);
+       [CCode (cheader_filename = "gsf/gsf-timestamp.h")]
+       public static void value_set_timestamp (GLib.Value value, Gsf.Timestamp stamp);
+       [CCode (cheader_filename = "gsf/gsf-libxml.h")]
+       public static int xmlDocFormatDump (Gsf.Output output, Xml.Doc cur, string encoding, bool format);
+       [CCode (cheader_filename = "gsf/gsf-libxml.h")]
+       public static bool xml_gvalue_from_str (GLib.Value res, GLib.Type t, string str);
+       [CCode (cheader_filename = "gsf/gsf-libxml.h")]
+       public static Xml.ParserCtxt xml_parser_context (Gsf.Input input);
+}
diff --git a/vapi/packages/libgsf-1/libgsf-1-custom.vala b/vapi/packages/libgsf-1/libgsf-1-custom.vala
new file mode 100644 (file)
index 0000000..ca05ed2
--- /dev/null
@@ -0,0 +1,10 @@
+namespace Gsf {
+  public struct off_t : int64 {
+  }
+  /*  public static delegate void XMLInNodeStartFunc(XMLIn xin, string[] attrs);
+      public static delegate void XMLInNodeEndFunc(XMLIn xin, XMLBlob unknown);*/
+  [CCode (cheader_filename = "gsf/gsf-input-impl.h")]
+  public class Input {
+    public static extern Gsf.Input uncompress(Gsf.Input# src);
+  }
+}
\ No newline at end of file
diff --git a/vapi/packages/libgsf-1/libgsf-1.deps b/vapi/packages/libgsf-1/libgsf-1.deps
new file mode 100644 (file)
index 0000000..e17ccd5
--- /dev/null
@@ -0,0 +1 @@
+libxml-2.0
\ No newline at end of file
diff --git a/vapi/packages/libgsf-1/libgsf-1.excludes b/vapi/packages/libgsf-1/libgsf-1.excludes
new file mode 100644 (file)
index 0000000..85360f5
--- /dev/null
@@ -0,0 +1 @@
+gsf-impl-utils.h
\ No newline at end of file
diff --git a/vapi/packages/libgsf-1/libgsf-1.files b/vapi/packages/libgsf-1/libgsf-1.files
new file mode 100644 (file)
index 0000000..0b74a07
--- /dev/null
@@ -0,0 +1,2 @@
+include/libgsf-1/gsf
+lib/libgsf-1.so
diff --git a/vapi/packages/libgsf-1/libgsf-1.gi b/vapi/packages/libgsf-1/libgsf-1.gi
new file mode 100644 (file)
index 0000000..39ddf41
--- /dev/null
@@ -0,0 +1,1835 @@
+<?xml version="1.0"?>
+<api version="1.0">
+       <namespace name="Gsf">
+               <function name="base64_decode_simple" symbol="gsf_base64_decode_simple">
+                       <return-type type="size_t"/>
+                       <parameters>
+                               <parameter name="data" type="guint8*"/>
+                               <parameter name="len" type="size_t"/>
+                       </parameters>
+               </function>
+               <function name="base64_decode_step" symbol="gsf_base64_decode_step">
+                       <return-type type="size_t"/>
+                       <parameters>
+                               <parameter name="in" type="guint8*"/>
+                               <parameter name="len" type="size_t"/>
+                               <parameter name="out" type="guint8*"/>
+                               <parameter name="state" type="int*"/>
+                               <parameter name="save" type="guint*"/>
+                       </parameters>
+               </function>
+               <function name="base64_encode_close" symbol="gsf_base64_encode_close">
+                       <return-type type="size_t"/>
+                       <parameters>
+                               <parameter name="in" type="guint8*"/>
+                               <parameter name="inlen" type="size_t"/>
+                               <parameter name="break_lines" type="gboolean"/>
+                               <parameter name="out" type="guint8*"/>
+                               <parameter name="state" type="int*"/>
+                               <parameter name="save" type="guint*"/>
+                       </parameters>
+               </function>
+               <function name="base64_encode_simple" symbol="gsf_base64_encode_simple">
+                       <return-type type="guint8*"/>
+                       <parameters>
+                               <parameter name="data" type="guint8*"/>
+                               <parameter name="len" type="size_t"/>
+                       </parameters>
+               </function>
+               <function name="base64_encode_step" symbol="gsf_base64_encode_step">
+                       <return-type type="size_t"/>
+                       <parameters>
+                               <parameter name="in" type="guint8*"/>
+                               <parameter name="len" type="size_t"/>
+                               <parameter name="break_lines" type="gboolean"/>
+                               <parameter name="out" type="guint8*"/>
+                               <parameter name="state" type="int*"/>
+                               <parameter name="save" type="guint*"/>
+                       </parameters>
+               </function>
+               <function name="doc_meta_dump" symbol="gsf_doc_meta_dump">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="meta" type="GsfDocMetaData*"/>
+                       </parameters>
+               </function>
+               <function name="error_quark" symbol="gsf_error_quark">
+                       <return-type type="GQuark"/>
+               </function>
+               <function name="extension_pointer" symbol="gsf_extension_pointer">
+                       <return-type type="char*"/>
+                       <parameters>
+                               <parameter name="path" type="char*"/>
+                       </parameters>
+               </function>
+               <function name="filename_to_utf8" symbol="gsf_filename_to_utf8">
+                       <return-type type="char*"/>
+                       <parameters>
+                               <parameter name="filename" type="char*"/>
+                               <parameter name="quoted" type="gboolean"/>
+                       </parameters>
+               </function>
+               <function name="iconv_close" symbol="gsf_iconv_close">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="handle" type="GIConv"/>
+                       </parameters>
+               </function>
+               <function name="init" symbol="gsf_init">
+                       <return-type type="void"/>
+               </function>
+               <function name="init_dynamic" symbol="gsf_init_dynamic">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="module" type="GTypeModule*"/>
+                       </parameters>
+               </function>
+               <function name="le_get_double" symbol="gsf_le_get_double">
+                       <return-type type="double"/>
+                       <parameters>
+                               <parameter name="p" type="void*"/>
+                       </parameters>
+               </function>
+               <function name="le_get_float" symbol="gsf_le_get_float">
+                       <return-type type="float"/>
+                       <parameters>
+                               <parameter name="p" type="void*"/>
+                       </parameters>
+               </function>
+               <function name="le_get_guint64" symbol="gsf_le_get_guint64">
+                       <return-type type="guint64"/>
+                       <parameters>
+                               <parameter name="p" type="void*"/>
+                       </parameters>
+               </function>
+               <function name="le_set_double" symbol="gsf_le_set_double">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="p" type="void*"/>
+                               <parameter name="d" type="double"/>
+                       </parameters>
+               </function>
+               <function name="le_set_float" symbol="gsf_le_set_float">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="p" type="void*"/>
+                               <parameter name="f" type="float"/>
+                       </parameters>
+               </function>
+               <function name="mem_dump" symbol="gsf_mem_dump">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="ptr" type="guint8*"/>
+                               <parameter name="len" type="size_t"/>
+                       </parameters>
+               </function>
+               <function name="msole_codepage_to_lid" symbol="gsf_msole_codepage_to_lid">
+                       <return-type type="guint"/>
+                       <parameters>
+                               <parameter name="codepage" type="int"/>
+                       </parameters>
+               </function>
+               <function name="msole_iconv_open_codepage_for_export" symbol="gsf_msole_iconv_open_codepage_for_export">
+                       <return-type type="GIConv"/>
+                       <parameters>
+                               <parameter name="codepage_to" type="int"/>
+                       </parameters>
+               </function>
+               <function name="msole_iconv_open_codepage_for_import" symbol="gsf_msole_iconv_open_codepage_for_import">
+                       <return-type type="GIConv"/>
+                       <parameters>
+                               <parameter name="to" type="char*"/>
+                               <parameter name="codepage" type="int"/>
+                       </parameters>
+               </function>
+               <function name="msole_iconv_open_codepages_for_export" symbol="gsf_msole_iconv_open_codepages_for_export">
+                       <return-type type="GIConv"/>
+                       <parameters>
+                               <parameter name="codepage_to" type="int"/>
+                               <parameter name="from" type="char*"/>
+                       </parameters>
+               </function>
+               <function name="msole_iconv_open_for_export" symbol="gsf_msole_iconv_open_for_export">
+                       <return-type type="GIConv"/>
+               </function>
+               <function name="msole_iconv_open_for_import" symbol="gsf_msole_iconv_open_for_import">
+                       <return-type type="GIConv"/>
+                       <parameters>
+                               <parameter name="codepage" type="int"/>
+                       </parameters>
+               </function>
+               <function name="msole_iconv_win_codepage" symbol="gsf_msole_iconv_win_codepage">
+                       <return-type type="int"/>
+               </function>
+               <function name="msole_inflate" symbol="gsf_msole_inflate">
+                       <return-type type="GByteArray*"/>
+                       <parameters>
+                               <parameter name="input" type="GsfInput*"/>
+                               <parameter name="offset" type="gsf_off_t"/>
+                       </parameters>
+               </function>
+               <function name="msole_language_for_lid" symbol="gsf_msole_language_for_lid">
+                       <return-type type="char*"/>
+                       <parameters>
+                               <parameter name="lid" type="guint"/>
+                       </parameters>
+               </function>
+               <function name="msole_lid_for_language" symbol="gsf_msole_lid_for_language">
+                       <return-type type="guint"/>
+                       <parameters>
+                               <parameter name="lang" type="char*"/>
+                       </parameters>
+               </function>
+               <function name="msole_lid_to_codepage" symbol="gsf_msole_lid_to_codepage">
+                       <return-type type="int"/>
+                       <parameters>
+                               <parameter name="lid" type="guint"/>
+                       </parameters>
+               </function>
+               <function name="msole_lid_to_codepage_str" symbol="gsf_msole_lid_to_codepage_str">
+                       <return-type type="gchar*"/>
+                       <parameters>
+                               <parameter name="lid" type="guint"/>
+                       </parameters>
+               </function>
+               <function name="msole_metadata_read" symbol="gsf_msole_metadata_read">
+                       <return-type type="GError*"/>
+                       <parameters>
+                               <parameter name="in" type="GsfInput*"/>
+                               <parameter name="accum" type="GsfDocMetaData*"/>
+                       </parameters>
+               </function>
+               <function name="msole_metadata_write" symbol="gsf_msole_metadata_write">
+                       <return-type type="gboolean"/>
+                       <parameters>
+                               <parameter name="out" type="GsfOutput*"/>
+                               <parameter name="meta_data" type="GsfDocMetaData*"/>
+                               <parameter name="doc_not_component" type="gboolean"/>
+                       </parameters>
+               </function>
+               <function name="open_pkg_error_id" symbol="gsf_open_pkg_error_id">
+                       <return-type type="gint"/>
+               </function>
+               <function name="open_pkg_get_rel_by_id" symbol="gsf_open_pkg_get_rel_by_id">
+                       <return-type type="GsfInput*"/>
+                       <parameters>
+                               <parameter name="in" type="GsfInput*"/>
+                               <parameter name="id" type="char*"/>
+                       </parameters>
+               </function>
+               <function name="open_pkg_get_rel_by_type" symbol="gsf_open_pkg_get_rel_by_type">
+                       <return-type type="GsfInput*"/>
+                       <parameters>
+                               <parameter name="in" type="GsfInput*"/>
+                               <parameter name="type" type="char*"/>
+                       </parameters>
+               </function>
+               <function name="open_pkg_lookup_rel_by_id" symbol="gsf_open_pkg_lookup_rel_by_id">
+                       <return-type type="GsfOpenPkgRel*"/>
+                       <parameters>
+                               <parameter name="in" type="GsfInput*"/>
+                               <parameter name="id" type="char*"/>
+                       </parameters>
+               </function>
+               <function name="open_pkg_lookup_rel_by_type" symbol="gsf_open_pkg_lookup_rel_by_type">
+                       <return-type type="GsfOpenPkgRel*"/>
+                       <parameters>
+                               <parameter name="in" type="GsfInput*"/>
+                               <parameter name="type" type="char*"/>
+                       </parameters>
+               </function>
+               <function name="open_pkg_open_rel_by_id" symbol="gsf_open_pkg_open_rel_by_id">
+                       <return-type type="GsfInput*"/>
+                       <parameters>
+                               <parameter name="in" type="GsfInput*"/>
+                               <parameter name="id" type="char*"/>
+                               <parameter name="err" type="GError**"/>
+                       </parameters>
+               </function>
+               <function name="open_pkg_open_rel_by_type" symbol="gsf_open_pkg_open_rel_by_type">
+                       <return-type type="GsfInput*"/>
+                       <parameters>
+                               <parameter name="in" type="GsfInput*"/>
+                               <parameter name="type" type="char*"/>
+                               <parameter name="err" type="GError**"/>
+                       </parameters>
+               </function>
+               <function name="open_pkg_parse_rel_by_id" symbol="gsf_open_pkg_parse_rel_by_id">
+                       <return-type type="GError*"/>
+                       <parameters>
+                               <parameter name="xin" type="GsfXMLIn*"/>
+                               <parameter name="id" type="char*"/>
+                               <parameter name="dtd" type="GsfXMLInNode*"/>
+                               <parameter name="ns" type="GsfXMLInNS*"/>
+                       </parameters>
+               </function>
+               <function name="opendoc_metadata_read" symbol="gsf_opendoc_metadata_read">
+                       <return-type type="GError*"/>
+                       <parameters>
+                               <parameter name="input" type="GsfInput*"/>
+                               <parameter name="md" type="GsfDocMetaData*"/>
+                       </parameters>
+               </function>
+               <function name="opendoc_metadata_subtree" symbol="gsf_opendoc_metadata_subtree">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="doc" type="GsfXMLIn*"/>
+                               <parameter name="md" type="GsfDocMetaData*"/>
+                       </parameters>
+               </function>
+               <function name="opendoc_metadata_write" symbol="gsf_opendoc_metadata_write">
+                       <return-type type="gboolean"/>
+                       <parameters>
+                               <parameter name="output" type="GsfXMLOut*"/>
+                               <parameter name="md" type="GsfDocMetaData*"/>
+                       </parameters>
+               </function>
+               <function name="property_settings_collect" symbol="gsf_property_settings_collect">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="object_type" type="GType"/>
+                               <parameter name="p_params" type="GParameter**"/>
+                               <parameter name="p_n_params" type="size_t*"/>
+                               <parameter name="first_property_name" type="gchar*"/>
+                       </parameters>
+               </function>
+               <function name="property_settings_collect_valist" symbol="gsf_property_settings_collect_valist">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="object_type" type="GType"/>
+                               <parameter name="p_params" type="GParameter**"/>
+                               <parameter name="p_n_params" type="size_t*"/>
+                               <parameter name="first_property_name" type="gchar*"/>
+                               <parameter name="var_args" type="va_list"/>
+                       </parameters>
+               </function>
+               <function name="property_settings_free" symbol="gsf_property_settings_free">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="params" type="GParameter*"/>
+                               <parameter name="n_params" type="size_t"/>
+                       </parameters>
+               </function>
+               <function name="shutdown" symbol="gsf_shutdown">
+                       <return-type type="void"/>
+               </function>
+               <function name="shutdown_dynamic" symbol="gsf_shutdown_dynamic">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="module" type="GTypeModule*"/>
+                       </parameters>
+               </function>
+               <function name="value_get_docprop_varray" symbol="gsf_value_get_docprop_varray">
+                       <return-type type="GValueArray*"/>
+                       <parameters>
+                               <parameter name="value" type="GValue*"/>
+                       </parameters>
+               </function>
+               <function name="value_get_docprop_vector" symbol="gsf_value_get_docprop_vector">
+                       <return-type type="GsfDocPropVector*"/>
+                       <parameters>
+                               <parameter name="value" type="GValue*"/>
+                       </parameters>
+               </function>
+               <function name="value_set_timestamp" symbol="gsf_value_set_timestamp">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="value" type="GValue*"/>
+                               <parameter name="stamp" type="GsfTimestamp*"/>
+                       </parameters>
+               </function>
+               <function name="xmlDocFormatDump" symbol="gsf_xmlDocFormatDump">
+                       <return-type type="int"/>
+                       <parameters>
+                               <parameter name="output" type="GsfOutput*"/>
+                               <parameter name="cur" type="xmlDoc*"/>
+                               <parameter name="encoding" type="char*"/>
+                               <parameter name="format" type="gboolean"/>
+                       </parameters>
+               </function>
+               <function name="xml_gvalue_from_str" symbol="gsf_xml_gvalue_from_str">
+                       <return-type type="gboolean"/>
+                       <parameters>
+                               <parameter name="res" type="GValue*"/>
+                               <parameter name="t" type="GType"/>
+                               <parameter name="str" type="char*"/>
+                       </parameters>
+               </function>
+               <function name="xml_parser_context" symbol="gsf_xml_parser_context">
+                       <return-type type="xmlParserCtxt*"/>
+                       <parameters>
+                               <parameter name="input" type="GsfInput*"/>
+                       </parameters>
+               </function>
+               <callback name="GsfXMLInExtDtor">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="xin" type="GsfXMLIn*"/>
+                               <parameter name="old_state" type="gpointer"/>
+                       </parameters>
+               </callback>
+               <callback name="GsfXMLInUnknownFunc">
+                       <return-type type="gboolean"/>
+                       <parameters>
+                               <parameter name="xin" type="GsfXMLIn*"/>
+                               <parameter name="elem" type="xmlChar*"/>
+                               <parameter name="attrs" type="xmlChar**"/>
+                       </parameters>
+               </callback>
+               <struct name="GsfDocProp">
+                       <method name="dump" symbol="gsf_doc_prop_dump">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="prop" type="GsfDocProp*"/>
+                               </parameters>
+                       </method>
+                       <method name="free" symbol="gsf_doc_prop_free">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="prop" type="GsfDocProp*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_link" symbol="gsf_doc_prop_get_link">
+                               <return-type type="char*"/>
+                               <parameters>
+                                       <parameter name="prop" type="GsfDocProp*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_name" symbol="gsf_doc_prop_get_name">
+                               <return-type type="char*"/>
+                               <parameters>
+                                       <parameter name="prop" type="GsfDocProp*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_val" symbol="gsf_doc_prop_get_val">
+                               <return-type type="GValue*"/>
+                               <parameters>
+                                       <parameter name="prop" type="GsfDocProp*"/>
+                               </parameters>
+                       </method>
+                       <method name="new" symbol="gsf_doc_prop_new">
+                               <return-type type="GsfDocProp*"/>
+                               <parameters>
+                                       <parameter name="name" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_link" symbol="gsf_doc_prop_set_link">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="prop" type="GsfDocProp*"/>
+                                       <parameter name="link" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_val" symbol="gsf_doc_prop_set_val">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="prop" type="GsfDocProp*"/>
+                                       <parameter name="val" type="GValue*"/>
+                               </parameters>
+                       </method>
+                       <method name="swap_val" symbol="gsf_doc_prop_swap_val">
+                               <return-type type="GValue*"/>
+                               <parameters>
+                                       <parameter name="prop" type="GsfDocProp*"/>
+                                       <parameter name="val" type="GValue*"/>
+                               </parameters>
+                       </method>
+               </struct>
+               <struct name="GsfOpenPkgRel">
+                       <method name="get_target" symbol="gsf_open_pkg_rel_get_target">
+                               <return-type type="char*"/>
+                               <parameters>
+                                       <parameter name="rel" type="GsfOpenPkgRel*"/>
+                               </parameters>
+                       </method>
+                       <method name="is_extern" symbol="gsf_open_pkg_rel_is_extern">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="rel" type="GsfOpenPkgRel*"/>
+                               </parameters>
+                       </method>
+               </struct>
+               <struct name="GsfOpenPkgRels">
+               </struct>
+               <struct name="GsfXMLBlob">
+               </struct>
+               <struct name="GsfXMLIn">
+                       <method name="check_ns" symbol="gsf_xml_in_check_ns">
+                               <return-type type="char*"/>
+                               <parameters>
+                                       <parameter name="xin" type="GsfXMLIn*"/>
+                                       <parameter name="str" type="char*"/>
+                                       <parameter name="ns_id" type="unsigned"/>
+                               </parameters>
+                       </method>
+                       <method name="get_input" symbol="gsf_xml_in_get_input">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="xin" type="GsfXMLIn*"/>
+                               </parameters>
+                       </method>
+                       <method name="namecmp" symbol="gsf_xml_in_namecmp">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="xin" type="GsfXMLIn*"/>
+                                       <parameter name="str" type="char*"/>
+                                       <parameter name="ns_id" type="unsigned"/>
+                                       <parameter name="name" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="push_state" symbol="gsf_xml_in_push_state">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xin" type="GsfXMLIn*"/>
+                                       <parameter name="doc" type="GsfXMLInDoc*"/>
+                                       <parameter name="new_state" type="gpointer"/>
+                                       <parameter name="dtor" type="GsfXMLInExtDtor"/>
+                                       <parameter name="attrs" type="xmlChar**"/>
+                               </parameters>
+                       </method>
+                       <field name="user_state" type="gpointer"/>
+                       <field name="content" type="GString*"/>
+                       <field name="doc" type="GsfXMLInDoc*"/>
+                       <field name="node" type="GsfXMLInNode*"/>
+                       <field name="node_stack" type="GSList*"/>
+               </struct>
+               <struct name="GsfXMLInDoc">
+                       <method name="free" symbol="gsf_xml_in_doc_free">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="doc" type="GsfXMLInDoc*"/>
+                               </parameters>
+                       </method>
+                       <method name="new" symbol="gsf_xml_in_doc_new">
+                               <return-type type="GsfXMLInDoc*"/>
+                               <parameters>
+                                       <parameter name="nodes" type="GsfXMLInNode*"/>
+                                       <parameter name="ns" type="GsfXMLInNS*"/>
+                               </parameters>
+                       </method>
+                       <method name="parse" symbol="gsf_xml_in_doc_parse">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="doc" type="GsfXMLInDoc*"/>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="user_state" type="gpointer"/>
+                               </parameters>
+                       </method>
+                       <method name="set_unknown_handler" symbol="gsf_xml_in_doc_set_unknown_handler">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="doc" type="GsfXMLInDoc*"/>
+                                       <parameter name="handler" type="GsfXMLInUnknownFunc"/>
+                               </parameters>
+                       </method>
+               </struct>
+               <struct name="GsfXMLInNS">
+                       <field name="uri" type="char*"/>
+                       <field name="ns_id" type="unsigned"/>
+               </struct>
+               <struct name="GsfXMLInNode">
+                       <field name="id" type="char*"/>
+                       <field name="ns_id" type="int"/>
+                       <field name="name" type="char*"/>
+                       <field name="parent_id" type="char*"/>
+                       <field name="start" type="GCallback"/>
+                       <field name="end" type="GCallback"/>
+                       <field name="user_data" type="gpointer"/>
+                       <field name="has_content" type="GsfXMLContent"/>
+                       <field name="check_children_for_ns" type="unsigned"/>
+                       <field name="share_children_with_parent" type="unsigned"/>
+               </struct>
+               <struct name="gsf_off_t">
+               </struct>
+               <boxed name="GsfTimestamp" type-name="GsfTimestamp" get-type="gsf_timestamp_get_type">
+                       <method name="as_string" symbol="gsf_timestamp_as_string">
+                               <return-type type="char*"/>
+                               <parameters>
+                                       <parameter name="stamp" type="GsfTimestamp*"/>
+                               </parameters>
+                       </method>
+                       <method name="copy" symbol="gsf_timestamp_copy">
+                               <return-type type="GsfTimestamp*"/>
+                               <parameters>
+                                       <parameter name="stamp" type="GsfTimestamp*"/>
+                               </parameters>
+                       </method>
+                       <method name="equal" symbol="gsf_timestamp_equal">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="a" type="GsfTimestamp*"/>
+                                       <parameter name="b" type="GsfTimestamp*"/>
+                               </parameters>
+                       </method>
+                       <method name="free" symbol="gsf_timestamp_free">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="stamp" type="GsfTimestamp*"/>
+                               </parameters>
+                       </method>
+                       <method name="hash" symbol="gsf_timestamp_hash">
+                               <return-type type="guint"/>
+                               <parameters>
+                                       <parameter name="stamp" type="GsfTimestamp*"/>
+                               </parameters>
+                       </method>
+                       <method name="parse" symbol="gsf_timestamp_parse">
+                               <return-type type="int"/>
+                               <parameters>
+                                       <parameter name="spec" type="char*"/>
+                                       <parameter name="stamp" type="GsfTimestamp*"/>
+                               </parameters>
+                       </method>
+                       <field name="date" type="GDate"/>
+                       <field name="seconds" type="glong"/>
+                       <field name="time_zone" type="GString"/>
+                       <field name="timet" type="guint32"/>
+               </boxed>
+               <enum name="GsfClipFormat">
+                       <member name="GSF_CLIP_FORMAT_WINDOWS_CLIPBOARD" value="-1"/>
+                       <member name="GSF_CLIP_FORMAT_MACINTOSH_CLIPBOARD" value="-2"/>
+                       <member name="GSF_CLIP_FORMAT_GUID" value="-3"/>
+                       <member name="GSF_CLIP_FORMAT_NO_DATA" value="0"/>
+                       <member name="GSF_CLIP_FORMAT_CLIPBOARD_FORMAT_NAME" value="1"/>
+                       <member name="GSF_CLIP_FORMAT_UNKNOWN" value="2"/>
+               </enum>
+               <enum name="GsfClipFormatWindows">
+                       <member name="GSF_CLIP_FORMAT_WINDOWS_ERROR" value="-1"/>
+                       <member name="GSF_CLIP_FORMAT_WINDOWS_UNKNOWN" value="-2"/>
+                       <member name="GSF_CLIP_FORMAT_WINDOWS_METAFILE" value="3"/>
+                       <member name="GSF_CLIP_FORMAT_WINDOWS_DIB" value="8"/>
+                       <member name="GSF_CLIP_FORMAT_WINDOWS_ENHANCED_METAFILE" value="14"/>
+               </enum>
+               <enum name="GsfError">
+                       <member name="GSF_ERROR_OUT_OF_MEMORY" value="0"/>
+                       <member name="GSF_ERROR_INVALID_DATA" value="1"/>
+               </enum>
+               <enum name="GsfOutputCsvQuotingMode" type-name="GsfOutputCsvQuotingMode" get-type="gsf_output_csv_quoting_mode_get_type">
+                       <member name="GSF_OUTPUT_CSV_QUOTING_MODE_NEVER" value="0"/>
+                       <member name="GSF_OUTPUT_CSV_QUOTING_MODE_AUTO" value="1"/>
+                       <member name="GSF_OUTPUT_CSV_QUOTING_MODE_ALWAYS" value="2"/>
+               </enum>
+               <enum name="GsfXMLContent">
+                       <member name="GSF_XML_NO_CONTENT" value="0"/>
+                       <member name="GSF_XML_CONTENT" value="1"/>
+                       <member name="GSF_XML_SHARED_CONTENT" value="2"/>
+               </enum>
+               <enum name="GsfZipCompressionMethod">
+                       <member name="GSF_ZIP_STORED" value="0"/>
+                       <member name="GSF_ZIP_SHRUNK" value="1"/>
+                       <member name="GSF_ZIP_REDUCEDx1" value="2"/>
+                       <member name="GSF_ZIP_REDUCEDx2" value="3"/>
+                       <member name="GSF_ZIP_REDUCEDx3" value="4"/>
+                       <member name="GSF_ZIP_REDUCEDx4" value="5"/>
+                       <member name="GSF_ZIP_IMPLODED" value="6"/>
+                       <member name="GSF_ZIP_TOKENIZED" value="7"/>
+                       <member name="GSF_ZIP_DEFLATED" value="8"/>
+                       <member name="GSF_ZIP_DEFLATED_BETTER" value="9"/>
+                       <member name="GSF_ZIP_IMPLODED_BETTER" value="10"/>
+               </enum>
+               <object name="GsfBlob" parent="GObject" type-name="GsfBlob" get-type="gsf_blob_get_type">
+                       <method name="get_size" symbol="gsf_blob_get_size">
+                               <return-type type="gsize"/>
+                               <parameters>
+                                       <parameter name="blob" type="GsfBlob*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="gsf_blob_new">
+                               <return-type type="GsfBlob*"/>
+                               <parameters>
+                                       <parameter name="size" type="gsize"/>
+                                       <parameter name="data_to_copy" type="gconstpointer"/>
+                                       <parameter name="error" type="GError**"/>
+                               </parameters>
+                       </constructor>
+                       <method name="peek_data" symbol="gsf_blob_peek_data">
+                               <return-type type="gconstpointer"/>
+                               <parameters>
+                                       <parameter name="blob" type="GsfBlob*"/>
+                               </parameters>
+                       </method>
+               </object>
+               <object name="GsfClipData" parent="GObject" type-name="GsfClipData" get-type="gsf_clip_data_get_type">
+                       <method name="get_data_blob" symbol="gsf_clip_data_get_data_blob">
+                               <return-type type="GsfBlob*"/>
+                               <parameters>
+                                       <parameter name="clip_data" type="GsfClipData*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_format" symbol="gsf_clip_data_get_format">
+                               <return-type type="GsfClipFormat"/>
+                               <parameters>
+                                       <parameter name="clip_data" type="GsfClipData*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_windows_clipboard_format" symbol="gsf_clip_data_get_windows_clipboard_format">
+                               <return-type type="GsfClipFormatWindows"/>
+                               <parameters>
+                                       <parameter name="clip_data" type="GsfClipData*"/>
+                                       <parameter name="error" type="GError**"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="gsf_clip_data_new">
+                               <return-type type="GsfClipData*"/>
+                               <parameters>
+                                       <parameter name="format" type="GsfClipFormat"/>
+                                       <parameter name="data_blob" type="GsfBlob*"/>
+                               </parameters>
+                       </constructor>
+                       <method name="peek_real_data" symbol="gsf_clip_data_peek_real_data">
+                               <return-type type="gconstpointer"/>
+                               <parameters>
+                                       <parameter name="clip_data" type="GsfClipData*"/>
+                                       <parameter name="ret_size" type="gsize*"/>
+                                       <parameter name="error" type="GError**"/>
+                               </parameters>
+                       </method>
+               </object>
+               <object name="GsfDocMetaData" parent="GObject" type-name="GsfDocMetaData" get-type="gsf_doc_meta_data_get_type">
+                       <method name="foreach" symbol="gsf_doc_meta_data_foreach">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="meta" type="GsfDocMetaData*"/>
+                                       <parameter name="func" type="GHFunc"/>
+                                       <parameter name="user_data" type="gpointer"/>
+                               </parameters>
+                       </method>
+                       <method name="insert" symbol="gsf_doc_meta_data_insert">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="meta" type="GsfDocMetaData*"/>
+                                       <parameter name="name" type="char*"/>
+                                       <parameter name="value" type="GValue*"/>
+                               </parameters>
+                       </method>
+                       <method name="lookup" symbol="gsf_doc_meta_data_lookup">
+                               <return-type type="GsfDocProp*"/>
+                               <parameters>
+                                       <parameter name="meta" type="GsfDocMetaData*"/>
+                                       <parameter name="name" type="char*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="gsf_doc_meta_data_new">
+                               <return-type type="GsfDocMetaData*"/>
+                       </constructor>
+                       <method name="remove" symbol="gsf_doc_meta_data_remove">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="meta" type="GsfDocMetaData*"/>
+                                       <parameter name="name" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="size" symbol="gsf_doc_meta_data_size">
+                               <return-type type="gsize"/>
+                               <parameters>
+                                       <parameter name="meta" type="GsfDocMetaData*"/>
+                               </parameters>
+                       </method>
+                       <method name="steal" symbol="gsf_doc_meta_data_steal">
+                               <return-type type="GsfDocProp*"/>
+                               <parameters>
+                                       <parameter name="meta" type="GsfDocMetaData*"/>
+                                       <parameter name="name" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="store" symbol="gsf_doc_meta_data_store">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="meta" type="GsfDocMetaData*"/>
+                                       <parameter name="prop" type="GsfDocProp*"/>
+                               </parameters>
+                       </method>
+               </object>
+               <object name="GsfDocPropVector" parent="GObject" type-name="GsfDocPropVector" get-type="gsf_docprop_vector_get_type">
+                       <method name="append" symbol="gsf_docprop_vector_append">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="vector" type="GsfDocPropVector*"/>
+                                       <parameter name="value" type="GValue*"/>
+                               </parameters>
+                       </method>
+                       <method name="as_string" symbol="gsf_docprop_vector_as_string">
+                               <return-type type="gchar*"/>
+                               <parameters>
+                                       <parameter name="vector" type="GsfDocPropVector*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="gsf_docprop_vector_new">
+                               <return-type type="GsfDocPropVector*"/>
+                       </constructor>
+               </object>
+               <object name="GsfInfile" parent="GsfInput" type-name="GsfInfile" get-type="gsf_infile_get_type">
+                       <method name="child_by_index" symbol="gsf_infile_child_by_index">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="infile" type="GsfInfile*"/>
+                                       <parameter name="i" type="int"/>
+                               </parameters>
+                       </method>
+                       <method name="child_by_name" symbol="gsf_infile_child_by_name">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="infile" type="GsfInfile*"/>
+                                       <parameter name="name" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="child_by_vname" symbol="gsf_infile_child_by_vname">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="infile" type="GsfInfile*"/>
+                                       <parameter name="name" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="name_by_index" symbol="gsf_infile_name_by_index">
+                               <return-type type="char*"/>
+                               <parameters>
+                                       <parameter name="infile" type="GsfInfile*"/>
+                                       <parameter name="i" type="int"/>
+                               </parameters>
+                       </method>
+                       <method name="num_children" symbol="gsf_infile_num_children">
+                               <return-type type="int"/>
+                               <parameters>
+                                       <parameter name="infile" type="GsfInfile*"/>
+                               </parameters>
+                       </method>
+                       <vfunc name="child_by_index">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="infile" type="GsfInfile*"/>
+                                       <parameter name="i" type="int"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </vfunc>
+                       <vfunc name="child_by_name">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="infile" type="GsfInfile*"/>
+                                       <parameter name="name" type="char*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </vfunc>
+                       <vfunc name="name_by_index">
+                               <return-type type="char*"/>
+                               <parameters>
+                                       <parameter name="infile" type="GsfInfile*"/>
+                                       <parameter name="i" type="int"/>
+                               </parameters>
+                       </vfunc>
+                       <vfunc name="num_children">
+                               <return-type type="int"/>
+                               <parameters>
+                                       <parameter name="infile" type="GsfInfile*"/>
+                               </parameters>
+                       </vfunc>
+               </object>
+               <object name="GsfInfileMSOle" parent="GsfInfile" type-name="GsfInfileMSOle" get-type="gsf_infile_msole_get_type">
+                       <method name="get_class_id" symbol="gsf_infile_msole_get_class_id">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="ole" type="GsfInfileMSOle*"/>
+                                       <parameter name="res" type="guint8*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="gsf_infile_msole_new">
+                               <return-type type="GsfInfile*"/>
+                               <parameters>
+                                       <parameter name="source" type="GsfInput*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </constructor>
+               </object>
+               <object name="GsfInfileMSVBA" parent="GsfInfile" type-name="GsfInfileMSVBA" get-type="gsf_infile_msvba_get_type">
+                       <constructor name="new" symbol="gsf_infile_msvba_new">
+                               <return-type type="GsfInfile*"/>
+                               <parameters>
+                                       <parameter name="source" type="GsfInfile*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </constructor>
+               </object>
+               <object name="GsfInfileStdio" parent="GsfInfile" type-name="GsfInfileStdio" get-type="gsf_infile_stdio_get_type">
+                       <constructor name="new" symbol="gsf_infile_stdio_new">
+                               <return-type type="GsfInfile*"/>
+                               <parameters>
+                                       <parameter name="root" type="char*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </constructor>
+               </object>
+               <object name="GsfInfileZip" parent="GsfInfile" type-name="GsfInfileZip" get-type="gsf_infile_zip_get_type">
+                       <constructor name="new" symbol="gsf_infile_zip_new">
+                               <return-type type="GsfInfile*"/>
+                               <parameters>
+                                       <parameter name="source" type="GsfInput*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </constructor>
+                       <property name="compression-level" type="gint" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <property name="internal-parent" type="GsfInfileZip*" readable="0" writable="1" construct="0" construct-only="1"/>
+                       <property name="source" type="GsfInput*" readable="1" writable="1" construct="0" construct-only="1"/>
+               </object>
+               <object name="GsfInput" parent="GObject" type-name="GsfInput" get-type="gsf_input_get_type">
+                       <method name="container" symbol="gsf_input_container">
+                               <return-type type="GsfInfile*"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                               </parameters>
+                       </method>
+                       <method name="copy" symbol="gsf_input_copy">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="output" type="GsfOutput*"/>
+                               </parameters>
+                       </method>
+                       <method name="dump" symbol="gsf_input_dump">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="dump_as_hex" type="gboolean"/>
+                               </parameters>
+                       </method>
+                       <method name="dup" symbol="gsf_input_dup">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </method>
+                       <method name="eof" symbol="gsf_input_eof">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                               </parameters>
+                       </method>
+                       <method name="error" symbol="gsf_input_error">
+                               <return-type type="GQuark"/>
+                       </method>
+                       <method name="error_id" symbol="gsf_input_error_id">
+                               <return-type type="GQuark"/>
+                       </method>
+                       <method name="mmap_new" symbol="gsf_input_mmap_new">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="filename" type="char*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </method>
+                       <method name="name" symbol="gsf_input_name">
+                               <return-type type="char*"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                               </parameters>
+                       </method>
+                       <method name="read" symbol="gsf_input_read">
+                               <return-type type="guint8*"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="num_bytes" type="size_t"/>
+                                       <parameter name="optional_buffer" type="guint8*"/>
+                               </parameters>
+                       </method>
+                       <method name="remaining" symbol="gsf_input_remaining">
+                               <return-type type="gsf_off_t"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                               </parameters>
+                       </method>
+                       <method name="seek" symbol="gsf_input_seek">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="offset" type="gsf_off_t"/>
+                                       <parameter name="whence" type="GSeekType"/>
+                               </parameters>
+                       </method>
+                       <method name="seek_emulate" symbol="gsf_input_seek_emulate">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="pos" type="gsf_off_t"/>
+                               </parameters>
+                       </method>
+                       <method name="set_container" symbol="gsf_input_set_container">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="container" type="GsfInfile*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_name" symbol="gsf_input_set_name">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="name" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_name_from_filename" symbol="gsf_input_set_name_from_filename">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="filename" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_size" symbol="gsf_input_set_size">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="size" type="gsf_off_t"/>
+                               </parameters>
+                       </method>
+                       <method name="sibling" symbol="gsf_input_sibling">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="name" type="char*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </method>
+                       <method name="size" symbol="gsf_input_size">
+                               <return-type type="gsf_off_t"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                               </parameters>
+                       </method>
+                       <method name="tell" symbol="gsf_input_tell">
+                               <return-type type="gsf_off_t"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                               </parameters>
+                       </method>
+                       <method name="uncompress" symbol="gsf_input_uncompress">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="src" type="GsfInput*"/>
+                               </parameters>
+                       </method>
+                       <property name="eof" type="gboolean" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <property name="name" type="char*" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <property name="position" type="gint64" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <property name="remaining" type="gint64" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <property name="size" type="gint64" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <vfunc name="Dup">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </vfunc>
+                       <vfunc name="OpenSibling">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="path" type="char*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </vfunc>
+                       <vfunc name="Read">
+                               <return-type type="guint8*"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="num_bytes" type="size_t"/>
+                                       <parameter name="optional_buffer" type="guint8*"/>
+                               </parameters>
+                       </vfunc>
+                       <vfunc name="Seek">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                                       <parameter name="offset" type="gsf_off_t"/>
+                                       <parameter name="whence" type="GSeekType"/>
+                               </parameters>
+                       </vfunc>
+                       <field name="size" type="gsf_off_t"/>
+                       <field name="cur_offset" type="gsf_off_t"/>
+                       <field name="name" type="char*"/>
+                       <field name="container" type="GsfInfile*"/>
+               </object>
+               <object name="GsfInputGZip" parent="GsfInput" type-name="GsfInputGZip" get-type="gsf_input_gzip_get_type">
+                       <constructor name="new" symbol="gsf_input_gzip_new">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="source" type="GsfInput*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </constructor>
+                       <property name="raw" type="gboolean" readable="1" writable="1" construct="0" construct-only="1"/>
+                       <property name="source" type="GsfInput*" readable="1" writable="1" construct="0" construct-only="1"/>
+                       <property name="uncompressed-size" type="gint64" readable="1" writable="1" construct="0" construct-only="1"/>
+               </object>
+               <object name="GsfInputHTTP" parent="GsfInput" type-name="GsfInputHTTP" get-type="gsf_input_http_get_type">
+                       <method name="get_content_type" symbol="gsf_input_http_get_content_type">
+                               <return-type type="gchar*"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInputHTTP*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_url" symbol="gsf_input_http_get_url">
+                               <return-type type="gchar*"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInputHTTP*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="gsf_input_http_new">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="url" type="gchar*"/>
+                                       <parameter name="error" type="GError**"/>
+                               </parameters>
+                       </constructor>
+                       <property name="content-type" type="char*" readable="1" writable="1" construct="0" construct-only="1"/>
+                       <property name="url" type="char*" readable="1" writable="1" construct="0" construct-only="1"/>
+               </object>
+               <object name="GsfInputMemory" parent="GsfInput" type-name="GsfInputMemory" get-type="gsf_input_memory_get_type">
+                       <constructor name="new" symbol="gsf_input_memory_new">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="buf" type="guint8*"/>
+                                       <parameter name="length" type="gsf_off_t"/>
+                                       <parameter name="needs_free" type="gboolean"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_clone" symbol="gsf_input_memory_new_clone">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="buf" type="guint8*"/>
+                                       <parameter name="length" type="gsf_off_t"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_from_bzip" symbol="gsf_input_memory_new_from_bzip">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="source" type="GsfInput*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_from_iochannel" symbol="gsf_input_memory_new_from_iochannel">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="channel" type="GIOChannel*"/>
+                                       <parameter name="error" type="GError**"/>
+                               </parameters>
+                       </constructor>
+               </object>
+               <object name="GsfInputProxy" parent="GsfInput" type-name="GsfInputProxy" get-type="gsf_input_proxy_get_type">
+                       <constructor name="new" symbol="gsf_input_proxy_new">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="source" type="GsfInput*"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_section" symbol="gsf_input_proxy_new_section">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="source" type="GsfInput*"/>
+                                       <parameter name="offset" type="gsf_off_t"/>
+                                       <parameter name="size" type="gsf_off_t"/>
+                               </parameters>
+                       </constructor>
+               </object>
+               <object name="GsfInputStdio" parent="GsfInput" type-name="GsfInputStdio" get-type="gsf_input_stdio_get_type">
+                       <constructor name="new" symbol="gsf_input_stdio_new">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="filename" type="char*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_FILE" symbol="gsf_input_stdio_new_FILE">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="filename" type="char*"/>
+                                       <parameter name="file" type="FILE*"/>
+                                       <parameter name="keep_open" type="gboolean"/>
+                               </parameters>
+                       </constructor>
+               </object>
+               <object name="GsfInputTextline" parent="GsfInput" type-name="GsfInputTextline" get-type="gsf_input_textline_get_type">
+                       <method name="ascii_gets" symbol="gsf_input_textline_ascii_gets">
+                               <return-type type="unsigned*"/>
+                               <parameters>
+                                       <parameter name="textline" type="GsfInputTextline*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="gsf_input_textline_new">
+                               <return-type type="GsfInput*"/>
+                               <parameters>
+                                       <parameter name="source" type="GsfInput*"/>
+                               </parameters>
+                       </constructor>
+                       <method name="utf8_gets" symbol="gsf_input_textline_utf8_gets">
+                               <return-type type="guint8*"/>
+                               <parameters>
+                                       <parameter name="textline" type="GsfInputTextline*"/>
+                               </parameters>
+                       </method>
+               </object>
+               <object name="GsfOutfile" parent="GsfOutput" type-name="GsfOutfile" get-type="gsf_outfile_get_type">
+                       <constructor name="new_child" symbol="gsf_outfile_new_child">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="outfile" type="GsfOutfile*"/>
+                                       <parameter name="name" type="char*"/>
+                                       <parameter name="is_dir" type="gboolean"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_child_full" symbol="gsf_outfile_new_child_full">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="outfile" type="GsfOutfile*"/>
+                                       <parameter name="name" type="char*"/>
+                                       <parameter name="is_dir" type="gboolean"/>
+                                       <parameter name="first_property_name" type="char*"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_child_varg" symbol="gsf_outfile_new_child_varg">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="outfile" type="GsfOutfile*"/>
+                                       <parameter name="name" type="char*"/>
+                                       <parameter name="is_dir" type="gboolean"/>
+                                       <parameter name="first_property_name" type="char*"/>
+                                       <parameter name="args" type="va_list"/>
+                               </parameters>
+                       </constructor>
+                       <vfunc name="new_child">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="outfile" type="GsfOutfile*"/>
+                                       <parameter name="name" type="char*"/>
+                                       <parameter name="is_dir" type="gboolean"/>
+                                       <parameter name="first_property_name" type="char*"/>
+                                       <parameter name="args" type="va_list"/>
+                               </parameters>
+                       </vfunc>
+               </object>
+               <object name="GsfOutfileMSOle" parent="GsfOutfile" type-name="GsfOutfileMSOle" get-type="gsf_outfile_msole_get_type">
+                       <constructor name="new" symbol="gsf_outfile_msole_new">
+                               <return-type type="GsfOutfile*"/>
+                               <parameters>
+                                       <parameter name="sink" type="GsfOutput*"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_full" symbol="gsf_outfile_msole_new_full">
+                               <return-type type="GsfOutfile*"/>
+                               <parameters>
+                                       <parameter name="sink" type="GsfOutput*"/>
+                                       <parameter name="bb_size" type="guint"/>
+                                       <parameter name="sb_size" type="guint"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_class_id" symbol="gsf_outfile_msole_set_class_id">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="ole" type="GsfOutfileMSOle*"/>
+                                       <parameter name="clsid" type="guint8*"/>
+                               </parameters>
+                       </method>
+               </object>
+               <object name="GsfOutfileOpenPkg" parent="GsfOutfile" type-name="GsfOutfileOpenPkg" get-type="gsf_outfile_open_pkg_get_type">
+                       <method name="add_extern_rel" symbol="gsf_outfile_open_pkg_add_extern_rel">
+                               <return-type type="char*"/>
+                               <parameters>
+                                       <parameter name="parent" type="GsfOutfileOpenPkg*"/>
+                                       <parameter name="target" type="char*"/>
+                                       <parameter name="content_type" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="add_rel" symbol="gsf_outfile_open_pkg_add_rel">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="dir" type="GsfOutfile*"/>
+                                       <parameter name="name" type="char*"/>
+                                       <parameter name="content_type" type="char*"/>
+                                       <parameter name="parent" type="GsfOutfile*"/>
+                                       <parameter name="type" type="char*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="gsf_outfile_open_pkg_new">
+                               <return-type type="GsfOutfile*"/>
+                               <parameters>
+                                       <parameter name="sink" type="GsfOutfile*"/>
+                               </parameters>
+                       </constructor>
+                       <method name="relate" symbol="gsf_outfile_open_pkg_relate">
+                               <return-type type="char*"/>
+                               <parameters>
+                                       <parameter name="child" type="GsfOutfileOpenPkg*"/>
+                                       <parameter name="parent" type="GsfOutfileOpenPkg*"/>
+                                       <parameter name="type" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_content_type" symbol="gsf_outfile_open_pkg_set_content_type">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="open_pkg" type="GsfOutfileOpenPkg*"/>
+                                       <parameter name="content_type" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_sink" symbol="gsf_outfile_open_pkg_set_sink">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="open_pkg" type="GsfOutfileOpenPkg*"/>
+                                       <parameter name="sink" type="GsfOutput*"/>
+                               </parameters>
+                       </method>
+                       <property name="content-type" type="char*" readable="1" writable="1" construct="0" construct-only="1"/>
+                       <property name="is-dir" type="gboolean" readable="1" writable="1" construct="0" construct-only="1"/>
+                       <property name="sink" type="GsfOutfile*" readable="1" writable="1" construct="0" construct-only="1"/>
+               </object>
+               <object name="GsfOutfileStdio" parent="GsfOutfile" type-name="GsfOutfileStdio" get-type="gsf_outfile_stdio_get_type">
+                       <constructor name="new" symbol="gsf_outfile_stdio_new">
+                               <return-type type="GsfOutfile*"/>
+                               <parameters>
+                                       <parameter name="root" type="char*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_full" symbol="gsf_outfile_stdio_new_full">
+                               <return-type type="GsfOutfile*"/>
+                               <parameters>
+                                       <parameter name="root" type="char*"/>
+                                       <parameter name="err" type="GError**"/>
+                                       <parameter name="first_property_name" type="char*"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_valist" symbol="gsf_outfile_stdio_new_valist">
+                               <return-type type="GsfOutfile*"/>
+                               <parameters>
+                                       <parameter name="root" type="char*"/>
+                                       <parameter name="err" type="GError**"/>
+                                       <parameter name="first_property_name" type="char*"/>
+                                       <parameter name="var_args" type="va_list"/>
+                               </parameters>
+                       </constructor>
+               </object>
+               <object name="GsfOutfileZip" parent="GsfOutfile" type-name="GsfOutfileZip" get-type="gsf_outfile_zip_get_type">
+                       <constructor name="new" symbol="gsf_outfile_zip_new">
+                               <return-type type="GsfOutfile*"/>
+                               <parameters>
+                                       <parameter name="sink" type="GsfOutput*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_compression_method" symbol="gsf_outfile_zip_set_compression_method">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="zip" type="GsfOutfileZip*"/>
+                                       <parameter name="method" type="GsfZipCompressionMethod"/>
+                               </parameters>
+                       </method>
+                       <property name="compression-level" type="gint" readable="1" writable="1" construct="0" construct-only="1"/>
+                       <property name="entry-name" type="char*" readable="1" writable="1" construct="0" construct-only="1"/>
+                       <property name="sink" type="GsfOutput*" readable="1" writable="1" construct="0" construct-only="1"/>
+               </object>
+               <object name="GsfOutput" parent="GObject" type-name="GsfOutput" get-type="gsf_output_get_type">
+                       <method name="close" symbol="gsf_output_close">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                               </parameters>
+                       </method>
+                       <method name="container" symbol="gsf_output_container">
+                               <return-type type="GsfOutfile*"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                               </parameters>
+                       </method>
+                       <method name="error" symbol="gsf_output_error">
+                               <return-type type="GError*"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                               </parameters>
+                       </method>
+                       <method name="error_id" symbol="gsf_output_error_id">
+                               <return-type type="GQuark"/>
+                       </method>
+                       <method name="is_closed" symbol="gsf_output_is_closed">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                               </parameters>
+                       </method>
+                       <method name="name" symbol="gsf_output_name">
+                               <return-type type="char*"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                               </parameters>
+                       </method>
+                       <method name="printf" symbol="gsf_output_printf">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                                       <parameter name="format" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="puts" symbol="gsf_output_puts">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                                       <parameter name="line" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="seek" symbol="gsf_output_seek">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                                       <parameter name="offset" type="gsf_off_t"/>
+                                       <parameter name="whence" type="GSeekType"/>
+                               </parameters>
+                       </method>
+                       <method name="set_container" symbol="gsf_output_set_container">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                                       <parameter name="container" type="GsfOutfile*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_error" symbol="gsf_output_set_error">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                                       <parameter name="code" type="gint"/>
+                                       <parameter name="format" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_name" symbol="gsf_output_set_name">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                                       <parameter name="name" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_name_from_filename" symbol="gsf_output_set_name_from_filename">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                                       <parameter name="filename" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="size" symbol="gsf_output_size">
+                               <return-type type="gsf_off_t"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                               </parameters>
+                       </method>
+                       <method name="tell" symbol="gsf_output_tell">
+                               <return-type type="gsf_off_t"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                               </parameters>
+                       </method>
+                       <method name="unwrap" symbol="gsf_output_unwrap">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="wrapper" type="GObject*"/>
+                                       <parameter name="wrapee" type="GsfOutput*"/>
+                               </parameters>
+                       </method>
+                       <method name="vprintf" symbol="gsf_output_vprintf">
+                               <return-type type="gsf_off_t"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                                       <parameter name="format" type="char*"/>
+                                       <parameter name="args" type="va_list"/>
+                               </parameters>
+                       </method>
+                       <method name="wrap" symbol="gsf_output_wrap">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="wrapper" type="GObject*"/>
+                                       <parameter name="wrapee" type="GsfOutput*"/>
+                               </parameters>
+                       </method>
+                       <method name="write" symbol="gsf_output_write">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                                       <parameter name="num_bytes" type="size_t"/>
+                                       <parameter name="data" type="guint8*"/>
+                               </parameters>
+                       </method>
+                       <property name="is-closed" type="gboolean" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <property name="name" type="char*" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <property name="position" type="gint64" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <property name="size" type="gint64" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <vfunc name="Close">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                               </parameters>
+                       </vfunc>
+                       <vfunc name="Seek">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                                       <parameter name="offset" type="gsf_off_t"/>
+                                       <parameter name="whence" type="GSeekType"/>
+                               </parameters>
+                       </vfunc>
+                       <vfunc name="Vprintf">
+                               <return-type type="gsf_off_t"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                                       <parameter name="format" type="char*"/>
+                                       <parameter name="args" type="va_list"/>
+                               </parameters>
+                       </vfunc>
+                       <vfunc name="Write">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                                       <parameter name="num_bytes" type="size_t"/>
+                                       <parameter name="data" type="guint8*"/>
+                               </parameters>
+                       </vfunc>
+                       <field name="cur_size" type="gsf_off_t"/>
+                       <field name="cur_offset" type="gsf_off_t"/>
+                       <field name="name" type="char*"/>
+                       <field name="wrapped_by" type="GObject*"/>
+                       <field name="container" type="GsfOutfile*"/>
+                       <field name="err" type="GError*"/>
+                       <field name="is_closed" type="gboolean"/>
+                       <field name="printf_buf" type="char*"/>
+                       <field name="printf_buf_size" type="int"/>
+               </object>
+               <object name="GsfOutputBzip" parent="GsfOutput" type-name="GsfOutputBzip" get-type="gsf_output_bzip_get_type">
+                       <constructor name="new" symbol="gsf_output_bzip_new">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="sink" type="GsfOutput*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </constructor>
+               </object>
+               <object name="GsfOutputCsv" parent="GsfOutput" type-name="GsfOutputCsv" get-type="gsf_output_csv_get_type">
+                       <method name="write_eol" symbol="gsf_output_csv_write_eol">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="csv" type="GsfOutputCsv*"/>
+                               </parameters>
+                       </method>
+                       <method name="write_field" symbol="gsf_output_csv_write_field">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="csv" type="GsfOutputCsv*"/>
+                                       <parameter name="field" type="char*"/>
+                                       <parameter name="len" type="size_t"/>
+                               </parameters>
+                       </method>
+                       <property name="eol" type="char*" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="quote" type="char*" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="quoting-mode" type="GsfOutputCsvQuotingMode" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="quoting-on-whitespace" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="quoting-triggers" type="char*" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="separator" type="char*" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="sink" type="GsfOutput*" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <field name="sink" type="GsfOutput*"/>
+                       <field name="quote" type="char*"/>
+                       <field name="quote_len" type="size_t"/>
+                       <field name="quoting_mode" type="GsfOutputCsvQuotingMode"/>
+                       <field name="quoting_triggers" type="char*"/>
+                       <field name="eol" type="char*"/>
+                       <field name="eol_len" type="size_t"/>
+                       <field name="separator" type="char*"/>
+                       <field name="separator_len" type="size_t"/>
+                       <field name="fields_on_line" type="gboolean"/>
+                       <field name="buf" type="GString*"/>
+               </object>
+               <object name="GsfOutputGZip" parent="GsfOutput" type-name="GsfOutputGZip" get-type="gsf_output_gzip_get_type">
+                       <constructor name="new" symbol="gsf_output_gzip_new">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="sink" type="GsfOutput*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </constructor>
+                       <property name="raw" type="gboolean" readable="1" writable="1" construct="0" construct-only="1"/>
+                       <property name="sink" type="GsfOutput*" readable="1" writable="1" construct="0" construct-only="1"/>
+               </object>
+               <object name="GsfOutputIOChannel" parent="GsfOutput" type-name="GsfOutputIOChannel" get-type="gsf_output_iochannel_get_type">
+                       <constructor name="new" symbol="gsf_output_iochannel_new">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="channel" type="GIOChannel*"/>
+                               </parameters>
+                       </constructor>
+               </object>
+               <object name="GsfOutputIconv" parent="GsfOutput" type-name="GsfOutputIconv" get-type="gsf_output_iconv_get_type">
+                       <constructor name="new" symbol="gsf_output_iconv_new">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="sink" type="GsfOutput*"/>
+                                       <parameter name="dst" type="char*"/>
+                                       <parameter name="src" type="char*"/>
+                               </parameters>
+                       </constructor>
+                       <property name="fallback" type="char*" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="input-charset" type="char*" readable="1" writable="1" construct="0" construct-only="1"/>
+                       <property name="output-charset" type="char*" readable="1" writable="1" construct="0" construct-only="1"/>
+                       <property name="sink" type="GsfOutput*" readable="1" writable="1" construct="0" construct-only="1"/>
+               </object>
+               <object name="GsfOutputMemory" parent="GsfOutput" type-name="GsfOutputMemory" get-type="gsf_output_memory_get_type">
+                       <method name="get_bytes" symbol="gsf_output_memory_get_bytes">
+                               <return-type type="guint8*"/>
+                               <parameters>
+                                       <parameter name="mem" type="GsfOutputMemory*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="gsf_output_memory_new">
+                               <return-type type="GsfOutput*"/>
+                       </constructor>
+               </object>
+               <object name="GsfOutputStdio" parent="GsfOutput" type-name="GsfOutputStdio" get-type="gsf_output_stdio_get_type">
+                       <constructor name="new" symbol="gsf_output_stdio_new">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="filename" type="char*"/>
+                                       <parameter name="err" type="GError**"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_FILE" symbol="gsf_output_stdio_new_FILE">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="filename" type="char*"/>
+                                       <parameter name="file" type="FILE*"/>
+                                       <parameter name="keep_open" type="gboolean"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_full" symbol="gsf_output_stdio_new_full">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="filename" type="char*"/>
+                                       <parameter name="err" type="GError**"/>
+                                       <parameter name="first_property_name" type="char*"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_valist" symbol="gsf_output_stdio_new_valist">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="filename" type="char*"/>
+                                       <parameter name="err" type="GError**"/>
+                                       <parameter name="first_property_name" type="char*"/>
+                                       <parameter name="var_args" type="va_list"/>
+                               </parameters>
+                       </constructor>
+               </object>
+               <object name="GsfStructuredBlob" parent="GsfInfile" type-name="GsfStructuredBlob" get-type="gsf_structured_blob_get_type">
+                       <method name="read" symbol="gsf_structured_blob_read">
+                               <return-type type="GsfStructuredBlob*"/>
+                               <parameters>
+                                       <parameter name="input" type="GsfInput*"/>
+                               </parameters>
+                       </method>
+                       <method name="write" symbol="gsf_structured_blob_write">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="blob" type="GsfStructuredBlob*"/>
+                                       <parameter name="container" type="GsfOutfile*"/>
+                               </parameters>
+                       </method>
+               </object>
+               <object name="GsfXMLOut" parent="GObject" type-name="GsfXMLOut" get-type="gsf_xml_out_get_type">
+                       <method name="add_base64" symbol="gsf_xml_out_add_base64">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="data" type="guint8*"/>
+                                       <parameter name="len" type="unsigned"/>
+                               </parameters>
+                       </method>
+                       <method name="add_bool" symbol="gsf_xml_out_add_bool">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="val" type="gboolean"/>
+                               </parameters>
+                       </method>
+                       <method name="add_color" symbol="gsf_xml_out_add_color">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="r" type="unsigned"/>
+                                       <parameter name="g" type="unsigned"/>
+                                       <parameter name="b" type="unsigned"/>
+                               </parameters>
+                       </method>
+                       <method name="add_cstr" symbol="gsf_xml_out_add_cstr">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="val_utf8" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="add_cstr_unchecked" symbol="gsf_xml_out_add_cstr_unchecked">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="val_utf8" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="add_enum" symbol="gsf_xml_out_add_enum">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="etype" type="GType"/>
+                                       <parameter name="val" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="add_float" symbol="gsf_xml_out_add_float">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="val" type="double"/>
+                                       <parameter name="precision" type="int"/>
+                               </parameters>
+                       </method>
+                       <method name="add_gvalue" symbol="gsf_xml_out_add_gvalue">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="val" type="GValue*"/>
+                               </parameters>
+                       </method>
+                       <method name="add_int" symbol="gsf_xml_out_add_int">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="val" type="int"/>
+                               </parameters>
+                       </method>
+                       <method name="add_uint" symbol="gsf_xml_out_add_uint">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="val" type="unsigned"/>
+                               </parameters>
+                       </method>
+                       <method name="end_element" symbol="gsf_xml_out_end_element">
+                               <return-type type="char*"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_output" symbol="gsf_xml_out_get_output">
+                               <return-type type="GsfOutput*"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="gsf_xml_out_new">
+                               <return-type type="GsfXMLOut*"/>
+                               <parameters>
+                                       <parameter name="output" type="GsfOutput*"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_doc_type" symbol="gsf_xml_out_set_doc_type">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="type" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="simple_element" symbol="gsf_xml_out_simple_element">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="content" type="char*"/>
+                               </parameters>
+                       </method>
+                       <method name="simple_float_element" symbol="gsf_xml_out_simple_float_element">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="val" type="double"/>
+                                       <parameter name="precision" type="int"/>
+                               </parameters>
+                       </method>
+                       <method name="simple_int_element" symbol="gsf_xml_out_simple_int_element">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                                       <parameter name="val" type="int"/>
+                               </parameters>
+                       </method>
+                       <method name="start_element" symbol="gsf_xml_out_start_element">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="xout" type="GsfXMLOut*"/>
+                                       <parameter name="id" type="char*"/>
+                               </parameters>
+                       </method>
+                       <property name="pretty-print" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
+               </object>
+               <constant name="GSF_META_NAME_BYTE_COUNT" type="char*" value="gsf:byte-count"/>
+               <constant name="GSF_META_NAME_CASE_SENSITIVE" type="char*" value="gsf:case-sensitivity"/>
+               <constant name="GSF_META_NAME_CATEGORY" type="char*" value="gsf:category"/>
+               <constant name="GSF_META_NAME_CELL_COUNT" type="char*" value="gsf:cell-count"/>
+               <constant name="GSF_META_NAME_CHARACTER_COUNT" type="char*" value="gsf:character-count"/>
+               <constant name="GSF_META_NAME_CODEPAGE" type="char*" value="msole:codepage"/>
+               <constant name="GSF_META_NAME_COMPANY" type="char*" value="dc:publisher"/>
+               <constant name="GSF_META_NAME_CREATOR" type="char*" value="dc:creator"/>
+               <constant name="GSF_META_NAME_DATE_CREATED" type="char*" value="meta:creation-date"/>
+               <constant name="GSF_META_NAME_DATE_MODIFIED" type="char*" value="dc:date"/>
+               <constant name="GSF_META_NAME_DESCRIPTION" type="char*" value="dc:description"/>
+               <constant name="GSF_META_NAME_DICTIONARY" type="char*" value="gsf:dictionary"/>
+               <constant name="GSF_META_NAME_DOCUMENT_PARTS" type="char*" value="gsf:document-parts"/>
+               <constant name="GSF_META_NAME_EDITING_DURATION" type="char*" value="meta:editing-duration"/>
+               <constant name="GSF_META_NAME_GENERATOR" type="char*" value="meta:generator"/>
+               <constant name="GSF_META_NAME_HEADING_PAIRS" type="char*" value="gsf:heading-pairs"/>
+               <constant name="GSF_META_NAME_HIDDEN_SLIDE_COUNT" type="char*" value="gsf:hidden-slide-count"/>
+               <constant name="GSF_META_NAME_IMAGE_COUNT" type="char*" value="gsf:image-count"/>
+               <constant name="GSF_META_NAME_INITIAL_CREATOR" type="char*" value="meta:initial-creator"/>
+               <constant name="GSF_META_NAME_KEYWORD" type="char*" value="meta:keyword"/>
+               <constant name="GSF_META_NAME_KEYWORDS" type="char*" value="dc:keywords"/>
+               <constant name="GSF_META_NAME_LANGUAGE" type="char*" value="dc:language"/>
+               <constant name="GSF_META_NAME_LAST_PRINTED" type="char*" value="gsf:last-printed"/>
+               <constant name="GSF_META_NAME_LAST_SAVED_BY" type="char*" value="gsf:last-saved-by"/>
+               <constant name="GSF_META_NAME_LINE_COUNT" type="char*" value="gsf:line-count"/>
+               <constant name="GSF_META_NAME_LINKS_DIRTY" type="char*" value="gsf:links-dirty"/>
+               <constant name="GSF_META_NAME_LOCALE_SYSTEM_DEFAULT" type="char*" value="gsf:default-locale"/>
+               <constant name="GSF_META_NAME_MANAGER" type="char*" value="gsf:manager"/>
+               <constant name="GSF_META_NAME_MM_CLIP_COUNT" type="char*" value="gsf:MM-clip-count"/>
+               <constant name="GSF_META_NAME_MSOLE_UNKNOWN_17" type="char*" value="msole:unknown-doc-17"/>
+               <constant name="GSF_META_NAME_MSOLE_UNKNOWN_18" type="char*" value="msole:unknown-doc-18"/>
+               <constant name="GSF_META_NAME_MSOLE_UNKNOWN_19" type="char*" value="msole:unknown-doc-19"/>
+               <constant name="GSF_META_NAME_MSOLE_UNKNOWN_20" type="char*" value="msole:unknown-doc-20"/>
+               <constant name="GSF_META_NAME_MSOLE_UNKNOWN_21" type="char*" value="msole:unknown-doc-21"/>
+               <constant name="GSF_META_NAME_MSOLE_UNKNOWN_22" type="char*" value="msole:unknown-doc-22"/>
+               <constant name="GSF_META_NAME_MSOLE_UNKNOWN_23" type="char*" value="msole:unknown-doc-23"/>
+               <constant name="GSF_META_NAME_NOTE_COUNT" type="char*" value="gsf:note-count"/>
+               <constant name="GSF_META_NAME_OBJECT_COUNT" type="char*" value="gsf:object-count"/>
+               <constant name="GSF_META_NAME_PAGE_COUNT" type="char*" value="gsf:page-count"/>
+               <constant name="GSF_META_NAME_PARAGRAPH_COUNT" type="char*" value="gsf:paragraph-count"/>
+               <constant name="GSF_META_NAME_PRESENTATION_FORMAT" type="char*" value="gsf:presentation-format"/>
+               <constant name="GSF_META_NAME_PRINTED_BY" type="char*" value="meta:printed-by"/>
+               <constant name="GSF_META_NAME_PRINT_DATE" type="char*" value="meta:print-date"/>
+               <constant name="GSF_META_NAME_REVISION_COUNT" type="char*" value="meta:editing-cycles"/>
+               <constant name="GSF_META_NAME_SCALE" type="char*" value="gsf:scale"/>
+               <constant name="GSF_META_NAME_SECURITY" type="char*" value="gsf:security"/>
+               <constant name="GSF_META_NAME_SLIDE_COUNT" type="char*" value="gsf:slide-count"/>
+               <constant name="GSF_META_NAME_SPREADSHEET_COUNT" type="char*" value="gsf:spreadsheet-count"/>
+               <constant name="GSF_META_NAME_SUBJECT" type="char*" value="dc:subject"/>
+               <constant name="GSF_META_NAME_TABLE_COUNT" type="char*" value="gsf:table-count"/>
+               <constant name="GSF_META_NAME_TEMPLATE" type="char*" value="meta:template"/>
+               <constant name="GSF_META_NAME_THUMBNAIL" type="char*" value="gsf:thumbnail"/>
+               <constant name="GSF_META_NAME_TITLE" type="char*" value="dc:title"/>
+               <constant name="GSF_META_NAME_WORD_COUNT" type="char*" value="gsf:word-count"/>
+               <constant name="OLE_DEFAULT_BB_SHIFT" type="int" value="9"/>
+               <constant name="OLE_DEFAULT_SB_SHIFT" type="int" value="6"/>
+       </namespace>
+</api>
diff --git a/vapi/packages/libgsf-1/libgsf-1.metadata b/vapi/packages/libgsf-1/libgsf-1.metadata
new file mode 100644 (file)
index 0000000..a14e5d0
--- /dev/null
@@ -0,0 +1,245 @@
+Gsf cheader_filename="gsf/gsf.h"
+GsfClipFormat cheader_filename="gsf/gsf-clip-data.h"
+GsfClipFormatWindows cheader_filename="gsf/gsf-clip-data.h"
+GsfError errordomain="1" cheader_filename="gsf/gsf-utils.h"
+GsfOutputCsvQuotingMode cheader_filename="gsf/gsf-output-csv.h"
+GsfXMLContent cheader_filename="gsf/gsf-libxml.h"
+GsfZipCompressionMethod cheader_filename="gsf/gsf-outfile-zip.h"
+GsfBlob cheader_filename="gsf/gsf-blob.h"
+GsfDocPropVector cheader_filename="gsf/gsf-docprop-vector.h"
+GsfDocMetaData cheader_filename="gsf/gsf-doc-meta-data.h"
+GsfInfileMSOle cheader_filename="gsf/gsf-infile-msole.h"
+GsfInfileMSVBA cheader_filename="gsf/gsf-infile-msvba.h"
+GsfInfileStdio cheader_filename="gsf/gsf-infile-stdio.h"
+GsfInfile cheader_filename="gsf/gsf-infile-impl.h"
+GsfInfileZip cheader_filename="gsf/gsf-infile-zip.h"
+GsfInputGZip cheader_filename="gsf/gsf-input-gzip.h"
+GsfInputMemory cheader_filename="gsf/gsf-input-memory.h"
+GsfInputProxy cheader_filename="gsf/gsf-input-proxy.h"
+GsfInputStdio cheader_filename="gsf/gsf-input-stdio.h"
+GsfInputTextline cheader_filename="gsf/gsf-input-textline.h"
+GsfInputHTTP cheader_filename="gsf/gsf-input-http.h"
+GsfInput cheader_filename="gsf/gsf-input-impl.h"
+GsfOutfileMSOle cheader_filename="gsf/gsf-outfile-msole.h"
+GsfOutfileStdio cheader_filename="gsf/gsf-outfile-stdio.h"
+GsfOutfile cheader_filename="gsf/gsf-outfile-impl.h"
+GsfOutfileZip cheader_filename="gsf/gsf-outfile-zip.h"
+GsfOutputBzip cheader_filename="gsf/gsf-output-bzip.h"
+GsfOutputCsv cheader_filename="gsf/gsf-output-csv.h"
+GsfOutputGZip cheader_filename="gsf/gsf-output-gzip.h"
+GsfOutputIconv cheader_filename="gsf/gsf-output-iconv.h"
+GsfOutputIOChannel cheader_filename="gsf/gsf-output-iochannel.h"
+GsfOutputMemory cheader_filename="gsf/gsf-output-memory.h"
+GsfOutputStdio cheader_filename="gsf/gsf-output-stdio.h"
+GsfOutput cheader_filename="gsf/gsf-output-impl.h"
+GsfSharedMemory cheader_filename="gsf/gsf-infile-msvba.h"
+GsfStructuredBlob cheader_filename="gsf/gsf-structured-blob.h"
+GsfClipData cheader_filename="gsf/gsf-clip-data.h"
+GsfXMLOut cheader_filename="gsf/gsf-libxml.h"
+GsfDocProp cheader_filename="gsf/gsf-doc-meta-data.h"
+GsfTimestamp cheader_filename="gsf/gsf-timestamp.h"
+GsfXMLBlob cheader_filename="gsf/gsf-libxml.h"
+GsfXMLIn cheader_filename="gsf/gsf-libxml.h"
+GsfXMLInDoc cheader_filename="gsf/gsf-libxml.h"
+GsfXMLInNS cheader_filename="gsf/gsf-libxml.h"
+GsfXMLInNode cheader_filename="gsf/gsf-libxml.h"
+GsfXMLInExtDtor cheader_filename="gsf/gsf-libxml.h"
+GsfXMLInUnknownFunc cheader_filename="gsf/gsf-libxml.h"
+gsf_doc_meta_dump cheader_filename="gsf/gsf-doc-meta-data.h"
+gsf_filename_to_utf8 transfer_ownership="1" cheader_filename="gsf/gsf-utils.h"
+gsf_iconv_close cheader_filename="gsf/gsf-utils.h"
+gsf_mem_dump cheader_filename="gsf/gsf-utils.h"
+GsfOpenPkgRel cheader_filename="gsf/gsf-open-pkg-utils.h"
+GsfOpenPkgRels cheader_filename="gsf/gsf-open-pkg-utils.h"
+GsfOutfileOpenPkg cheader_filename="gsf/gsf-open-pkg-utils.h"
+gsf_off_t name="off_t" hidden="1"
+GsfInput:eof hidden="1"
+GsfInput:name hidden="1"
+GsfInput:remaining hidden="1"
+GsfInput:size hidden="1"
+GsfOutput:is-closed hidden="1"
+GsfOutput:name hidden="1"
+GsfOutput:size hidden="1"
+gsf_timestamp_as_string transfer_ownership="1"
+gsf_timestamp_copy transfer_ownership="1"
+gsf_docprop_vector_as_string transfer_ownership="1"
+gsf_doc_prop_swap_val transfer_ownership="1"
+gsf_input_uncompress hidden="1"
+gsf_input_sibling transfer_ownership="1"
+gsf_input_mmap_new transfer_ownership="1"
+gsf_input_dup transfer_ownership="1"
+gsf_infile_child_by_index transfer_ownership="1"
+gsf_infile_child_by_vname transfer_ownership="1" ellipsis="1"
+gsf_infile_child_by_name transfer_ownership="1"
+gsf_input_Dup transfer_ownership="1"
+gsf_input_OpenSibling transfer_ownership="1"
+gsf_input_textline_ascii_gets no_array_length="1" is_array="1" nullable="1"
+gsf_input_textline_utf8_gets no_array_length="1" is_array="1" nullable="1"
+gsf_outfile_open_pkg_add_rel transfer_ownership="1"
+gsf_outfile_new_child_varg hidden="1"
+gsf_structured_blob_read transfer_ownership="1"
+gsf_msole_inflate transfer_ownership="1"
+gsf_output_vprintf hidden="1"
+gsf_output_Vprintf hidden="1"
+gsf_output_printf ellipsis="1"
+gsf_input_stdio_new_FILE hidden="1"
+gsf_output_stdio_new_FILE hidden="1"
+gsf_output_stdio_new_valist hidden="1"
+gsf_output_stdio_new_full ellipsis="1"
+xmlChar name="string"
+gsf_xml_in_push_state.attrs no_array_length="1" is_array="1"
+gsf_xml_in_doc_new.nodes no_array_length="1" is_array="1"
+gsf_doc_prop_new.name transfer_ownership="1"
+gsf_doc_prop_set_val.val transfer_ownership="1"
+gsf_doc_prop_get_val nullable="1"
+gsf_doc_prop_set_link.link transfer_ownership="1"
+gsf_doc_prop_get_link nullable="1"
+gsf_input_read.optional_buffer no_array_length="1" is_array="1" nullable="1"
+gsf_input_read is_array="1" no_array_length="1" nullable="1"
+gsf_input_Read.optional_buffer is_array="1" no_array_length="1" nullable="1"
+gsf_input_Read is_array="1" nullable="1" no_array_length="1"
+gsf_doc_meta_data_lookup nullable="1"
+gsf_doc_meta_data_steal nullable="1"
+gsf_infile_child_by_vname nullable="1"
+gsf_infile_child_by_name nullable="1"
+gsf_infile_child_by_index nullable="1"
+gsf_infile_name_by_index nullable="1"
+gsf_input_container nullable="1"
+gsf_input_sibling nullable="1"
+gsf_input_name nullable="1"
+gsf_input_set_name.name nullable="1"
+gsf_input_set_container.container nullable="1"
+gsf_output_container nullable="1"
+gsf_output_name nullable="1"
+gsf_output_set_name.name nullable="1"
+gsf_output_set_container.container nullable="1"
+gsf_outfile_stdio_new_valist hidden="1"
+gsf_output_Write.data no_array_length="1" is_array="1"
+gsf_output_write.data no_array_length="1" is_array="1"
+gsf_output_memory_get_bytes is_array="1" no_array_length="1"
+gsf_base64_decode_simple.data is_array="1" no_array_length="1"
+gsf_base64_decode_step.in is_array="1" no_array_length="1"
+gsf_base64_decode_step.out is_array="1" no_array_length="1"
+gsf_base64_decode_step.state is_out="1"
+gsf_base64_decode_step.save is_out="1"
+gsf_base64_encode_close.in is_array="1" no_array_length="1"
+gsf_base64_encode_close.out is_array="1" no_array_length="1"
+gsf_base64_encode_close.state is_out="1"
+gsf_base64_encode_close.save is_out="1"
+gsf_base64_encode_simple.data is_array="1" no_array_length="1"
+gsf_base64_encode_simple cheader_filename="gsf/gsf-utils.h" is_array="1" no_array_length="1"
+gsf_base64_encode_step.in is_array="1" no_array_length="1"
+gsf_base64_encode_step.out is_array="1" no_array_length="1"
+gsf_base64_encode_step.state is_out="1"
+gsf_base64_encode_step.save is_out="1"
+gsf_mem_dump.ptr is_array="1" no_array_length="1"
+gsf_property_settings_collect_valist hidden="1"
+GSF_META_NAME_BYTE_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_CASE_SENSITIVE cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_CATEGORY cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_CELL_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_CHARACTER_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_CODEPAGE cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_COMPANY cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_CREATOR cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_DATE_CREATED cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_DATE_MODIFIED cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_DESCRIPTION cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_DICTIONARY cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_DOCUMENT_PARTS cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_EDITING_DURATION cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_GENERATOR cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_HEADING_PAIRS cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_HIDDEN_SLIDE_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_IMAGE_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_INITIAL_CREATOR cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_KEYWORD cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_KEYWORDS cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_LANGUAGE cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_LAST_PRINTED cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_LAST_SAVED_BY cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_LINE_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_LINKS_DIRTY cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_LOCALE_SYSTEM_DEFAULT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_MANAGER cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_MM_CLIP_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_MSOLE_UNKNOWN_17 cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_MSOLE_UNKNOWN_18 cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_MSOLE_UNKNOWN_19 cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_MSOLE_UNKNOWN_20 cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_MSOLE_UNKNOWN_21 cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_MSOLE_UNKNOWN_22 cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_MSOLE_UNKNOWN_23 cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_NOTE_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_OBJECT_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_PAGE_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_PARAGRAPH_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_PRESENTATION_FORMAT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_PRINTED_BY cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_PRINT_DATE cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_REVISION_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_SCALE cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_SECURITY cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_SLIDE_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_SPREADSHEET_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_SUBJECT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_TABLE_COUNT cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_TEMPLATE cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_THUMBNAIL cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_TITLE cheader_filename="gsf/gsf-meta-names.h"
+GSF_META_NAME_WORD_COUNT cheader_filename="gsf/gsf-meta-names.h"
+OLE_DEFAULT_BB_SHIFT cheader_filename="gsf/gsf-outfile-ole.h"
+OLE_DEFAULT_SB_SHIFT cheader_filename="gsf/gsf-outfile-ole.h"
+gsf_base64_decode_simple cheader_filename="gsf/gsf-utils.h"
+gsf_base64_decode_step cheader_filename="gsf/gsf-utils.h"
+gsf_base64_encode_close cheader_filename="gsf/gsf-utils.h"
+gsf_base64_encode_step cheader_filename="gsf/gsf-utils.h"
+gsf_doc_meta_dump cheader_filename="gsf/gsf-doc-meta-data.h"
+gsf_error_quark cheader_filename="gsf/gsf-utils.h"
+gsf_extension_pointer cheader_filename="gsf/gsf-utils.h"
+gsf_iconv_close cheader_filename="gsf/gsf-utils.h"
+gsf_init cheader_filename="gsf/gsf-utils.h"
+gsf_init_dynamic cheader_filename="gsf/gsf-utils.h"
+gsf_le_get_double cheader_filename="gsf/gsf-utils.h"
+gsf_le_get_float cheader_filename="gsf/gsf-utils.h"
+gsf_le_get_guint64 cheader_filename="gsf/gsf-utils.h"
+gsf_le_set_double cheader_filename="gsf/gsf-utils.h"
+gsf_le_set_float cheader_filename="gsf/gsf-utils.h"
+gsf_mem_dump cheader_filename="gsf/gsf-utils.h"
+gsf_msole_codepage_to_lid cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_iconv_open_codepage_for_export cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_iconv_open_codepage_for_import cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_iconv_open_codepages_for_export cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_iconv_open_for_export cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_iconv_open_for_import cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_iconv_win_codepage cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_inflate cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_language_for_lid cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_lid_for_language cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_lid_to_codepage cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_lid_to_codepage_str cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_metadata_read cheader_filename="gsf/gsf-msole-utils.h"
+gsf_msole_metadata_write cheader_filename="gsf/gsf-msole-utils.h"
+gsf_open_pkg_error_id cheader_filename="gsf/gsf-open-pkg-utils.h"
+gsf_open_pkg_get_rel_by_id transfer_ownership="1" cheader_filename="gsf/gsf-open-pkg-utils.h"
+gsf_open_pkg_get_rel_by_type transfer_ownership="1" cheader_filename="gsf/gsf-open-pkg-utils.h"
+gsf_open_pkg_lookup_rel_by_id cheader_filename="gsf/gsf-open-pkg-utils.h"
+gsf_open_pkg_lookup_rel_by_type cheader_filename="gsf/gsf-open-pkg-utils.h"
+gsf_open_pkg_open_rel_by_id transfer_ownership="1" cheader_filename="gsf/gsf-open-pkg-utils.h"
+gsf_open_pkg_open_rel_by_type transfer_ownership="1" cheader_filename="gsf/gsf-open-pkg-utils.h"
+gsf_open_pkg_parse_rel_by_id cheader_filename="gsf/gsf-open-pkg-utils.h"
+gsf_opendoc_metadata_read cheader_filename="gsf/gsf-opendoc-utils.h"
+gsf_opendoc_metadata_subtree cheader_filename="gsf/gsf-opendoc-utils.h"
+gsf_opendoc_metadata_write cheader_filename="gsf/gsf-opendoc-utils.h"
+gsf_property_settings_collect cheader_filename="gsf/gsf-utils.h"
+gsf_property_settings_collect.p_params is_array="1" no_array_length="1" 
+gsf_property_settings_collect.p_n_params is_ref="1"
+gsf_property_settings_free cheader_filename="gsf/gsf-utils.h"
+gsf_shutdown cheader_filename="gsf/gsf-utils.h"
+gsf_shutdown_dynamic cheader_filename="gsf/gsf-utils.h"
+gsf_value_get_docprop_varray cheader_filename="gsf/gsf-docprop-vector.h"
+gsf_value_get_docprop_vector cheader_filename="gsf/gsf-docprop-vector.h"
+gsf_value_set_timestamp cheader_filename="gsf/gsf-timestamp.h"
+gsf_xmlDocFormatDump cheader_filename="gsf/gsf-libxml.h"
+gsf_xml_gvalue_from_str cheader_filename="gsf/gsf-libxml.h"
+gsf_xml_parser_context transfer_ownership="1" cheader_filename="gsf/gsf-libxml.h"
\ No newline at end of file
diff --git a/vapi/packages/libgsf-1/libgsf-1.namespace b/vapi/packages/libgsf-1/libgsf-1.namespace
new file mode 100644 (file)
index 0000000..1b2820f
--- /dev/null
@@ -0,0 +1 @@
+Gsf
\ No newline at end of file
index f2c2033..70df1ea 100644 (file)
@@ -1,3 +1,4 @@
+gio-2.0
 pango
 gdk-pixbuf-2.0
 gdk-2.0