X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Foutput%2Fodt.c;h=bfc698e79aa11068363f16592ad5ec53d2b05c5f;hb=dde5a3c946871b4aab3d6b436438dd8df11db261;hp=59a628a6f9cb524241066f7fc41db24545318661;hpb=b5327298634757867c01485a8d0097b33c785a94;p=pspp-builds.git

diff --git a/src/output/odt.c b/src/output/odt.c
index 59a628a6..bfc698e7 100644
--- a/src/output/odt.c
+++ b/src/output/odt.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 2009 Free Software Foundation, Inc.
+   Copyright (C) 2009, 2010 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -16,31 +16,44 @@
 
 #include <config.h>
 
-
 /* A driver for creating OpenDocument Format text files from PSPP's output */
 
-#include <libpspp/assertion.h>
-#include <libpspp/version.h>
-
-#include <output/manager.h>
-#include <output/output.h>
-#include <output/table.h>
-
-#include <time.h>
+#include <errno.h>
+#include <libgen.h>
+#include <libxml/xmlwriter.h>
 #include <pwd.h>
 #include <sys/stat.h>
 #include <sys/types.h>
-
-#include <libgen.h>
-
-#include <libxml/xmlwriter.h>
-
-#include "xalloc.h"
+#include <time.h>
+#include <unistd.h>
+
+#include "libpspp/assertion.h"
+#include "libpspp/cast.h"
+#include "libpspp/str.h"
+#include "libpspp/version.h"
+#include "output/driver-provider.h"
+#include "output/message-item.h"
+#include "output/options.h"
+#include "output/tab.h"
+#include "output/table-item.h"
+#include "output/table-provider.h"
+#include "output/text-item.h"
+
+#include "gl/xalloc.h"
+#include "gl/error.h"
+
+#include "gettext.h"
+#define _(msgid) gettext (msgid)
 
 #define _xml(X) (const xmlChar *)(X)
 
-struct odt_driver_ext 
+struct odt_driver
 {
+  struct output_driver driver;
+
+  char *file_name;            /* Output file name. */
+  bool debug;
+
   /* The name of the temporary directory used to construct the ODF */
   char *dirname;
 
@@ -49,12 +62,25 @@ struct odt_driver_ext
 
   /* Writer fot the manifest.xml file */
   xmlTextWriterPtr manifest_wtr;
+
+  /* Number of tables so far. */
+  int table_num;
+
+  /* Name of current command. */
+  char *command_name;
 };
 
+static const struct output_driver_class odt_driver_class;
 
+static struct odt_driver *
+odt_driver_cast (struct output_driver *driver)
+{
+  assert (driver->class == &odt_driver_class);
+  return UP_CAST (driver, struct odt_driver, driver);
+}
 
 /* Create the "mimetype" file needed by ODF */
-static void
+static bool
 create_mimetype (const char *dirname)
 {
   FILE *fp;
@@ -62,16 +88,25 @@ create_mimetype (const char *dirname)
   ds_init_cstr (&filename, dirname);
   ds_put_cstr (&filename, "/mimetype");
   fp = fopen (ds_cstr (&filename), "w");
+
+  if (fp == NULL)
+    {
+      error (0, errno, _("error opening output file \"%s\""),
+             ds_cstr (&filename));
+      ds_destroy (&filename);
+      return false;
+    }
   ds_destroy (&filename);
 
-  assert (fp);
   fprintf (fp, "application/vnd.oasis.opendocument.text");
   fclose (fp);
+
+  return true;
 }
 
 /* Create a new XML file called FILENAME in the temp directory, and return a writer for it */
 static xmlTextWriterPtr
-create_writer (const struct odt_driver_ext *driver, const char *filename)
+create_writer (const struct odt_driver *driver, const char *filename)
 {
   char *copy = NULL;
   xmlTextWriterPtr w;
@@ -96,20 +131,112 @@ create_writer (const struct odt_driver_ext *driver, const char *filename)
 
 
 static void
-register_file (struct odt_driver_ext *x, const char *filename)
+register_file (struct odt_driver *odt, const char *filename)
 {
-  assert (x->manifest_wtr);
-  xmlTextWriterStartElement (x->manifest_wtr, _xml("manifest:file-entry"));
-  xmlTextWriterWriteAttribute (x->manifest_wtr, _xml("manifest:media-type"),  _xml("text/xml"));
-  xmlTextWriterWriteAttribute (x->manifest_wtr, _xml("manifest:full-path"),  _xml (filename));
-  xmlTextWriterEndElement (x->manifest_wtr);
+  assert (odt->manifest_wtr);
+  xmlTextWriterStartElement (odt->manifest_wtr, _xml("manifest:file-entry"));
+  xmlTextWriterWriteAttribute (odt->manifest_wtr, _xml("manifest:media-type"),  _xml("text/xml"));
+  xmlTextWriterWriteAttribute (odt->manifest_wtr, _xml("manifest:full-path"),  _xml (filename));
+  xmlTextWriterEndElement (odt->manifest_wtr);
+}
+
+static void
+write_style_data (struct odt_driver *odt)
+{
+  xmlTextWriterPtr w = create_writer (odt, "styles.xml");
+  register_file (odt, "styles.xml");
+
+  xmlTextWriterStartElement (w, _xml ("office:document-styles"));
+  xmlTextWriterWriteAttribute (w, _xml ("xmlns:office"),
+			       _xml ("urn:oasis:names:tc:opendocument:xmlns:office:1.0"));
+
+  xmlTextWriterWriteAttribute (w, _xml ("xmlns:style"),
+			       _xml ("urn:oasis:names:tc:opendocument:xmlns:style:1.0"));
+
+  xmlTextWriterWriteAttribute (w, _xml ("xmlns:fo"),
+			       _xml ("urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0") );
+
+  xmlTextWriterWriteAttribute (w, _xml ("office:version"),  _xml ("1.1"));
+			       
+
+
+  xmlTextWriterStartElement (w, _xml ("office:styles"));
+
+
+  {
+    xmlTextWriterStartElement (w, _xml ("style:style"));
+    xmlTextWriterWriteAttribute (w, _xml ("style:name"),
+				 _xml ("Standard"));
+
+    xmlTextWriterWriteAttribute (w, _xml ("style:family"),
+				 _xml ("paragraph"));
+
+    xmlTextWriterWriteAttribute (w, _xml ("style:class"),
+				 _xml ("text"));
+
+    xmlTextWriterEndElement (w); /* style:style */
+  }
+
+  {
+    xmlTextWriterStartElement (w, _xml ("style:style"));
+    xmlTextWriterWriteAttribute (w, _xml ("style:name"),
+				 _xml ("Table_20_Contents"));
+
+    xmlTextWriterWriteAttribute (w, _xml ("style:display-name"),
+				 _xml ("Table Contents"));
+
+    xmlTextWriterWriteAttribute (w, _xml ("style:family"),
+				 _xml ("paragraph"));
+
+    xmlTextWriterWriteAttribute (w, _xml ("style:parent-style-name"),
+				 _xml ("Standard"));
+
+    xmlTextWriterWriteAttribute (w, _xml ("style:class"),
+				 _xml ("extra"));
+
+    xmlTextWriterEndElement (w); /* style:style */
+  }
+
+  {
+    xmlTextWriterStartElement (w, _xml ("style:style"));
+    xmlTextWriterWriteAttribute (w, _xml ("style:name"),
+				 _xml ("Table_20_Heading"));
+
+    xmlTextWriterWriteAttribute (w, _xml ("style:display-name"),
+				 _xml ("Table Heading"));
+
+    xmlTextWriterWriteAttribute (w, _xml ("style:family"),
+				 _xml ("paragraph"));
+
+    xmlTextWriterWriteAttribute (w, _xml ("style:parent-style-name"),
+				 _xml ("Table_20_Contents"));
+
+    xmlTextWriterWriteAttribute (w, _xml ("style:class"),
+				 _xml ("extra"));
+
+
+    xmlTextWriterStartElement (w, _xml ("style:text-properties"));
+    xmlTextWriterWriteAttribute (w, _xml ("fo:font-weight"), _xml ("bold"));
+    xmlTextWriterWriteAttribute (w, _xml ("style:font-weight-asian"), _xml ("bold"));
+    xmlTextWriterWriteAttribute (w, _xml ("style:font-weight-complex"), _xml ("bold"));
+    xmlTextWriterEndElement (w); /* style:text-properties */
+
+    xmlTextWriterEndElement (w); /* style:style */
+  }
+
+
+  xmlTextWriterEndElement (w); /* office:styles */
+  xmlTextWriterEndElement (w); /* office:document-styles */
+
+  xmlTextWriterEndDocument (w);
+  xmlFreeTextWriter (w);
 }
 
 static void
-write_meta_data (struct odt_driver_ext *x)
+write_meta_data (struct odt_driver *odt)
 {
-  xmlTextWriterPtr w = create_writer (x, "meta.xml");
-  register_file (x, "meta.xml");
+  xmlTextWriterPtr w = create_writer (odt, "meta.xml");
+  register_file (odt, "meta.xml");
 
   xmlTextWriterStartElement (w, _xml ("office:document-meta"));
   xmlTextWriterWriteAttribute (w, _xml ("xmlns:office"), _xml ("urn:oasis:names:tc:opendocument:xmlns:office:1.0"));
@@ -158,248 +285,269 @@ write_meta_data (struct odt_driver_ext *x)
   xmlFreeTextWriter (w);
 }
 
-static bool
-odt_open_driver (const char *name, int types, struct substring option_string)
+enum
+{
+  output_file_arg,
+  boolean_arg,
+};
+
+static struct driver_option *
+opt (struct output_driver *d, struct string_map *options, const char *key,
+     const char *default_value)
 {
-  struct odt_driver_ext *x;
-  struct outp_driver *this = outp_allocate_driver (&odt_class, name, types);
+  return driver_option_get (d, options, key, default_value);
+}
+
+static struct output_driver *
+odt_create (const char *file_name, enum settings_output_devices device_type,
+            struct string_map *o)
+{
+  struct output_driver *d;
+  struct odt_driver *odt;
 
-  this->ext = x = xmalloc (sizeof *x);
+  odt = xzalloc (sizeof *odt);
+  d = &odt->driver;
+  output_driver_init (d, &odt_driver_class, file_name, device_type);
 
-  outp_register_driver (this);
+  odt->file_name = xstrdup (file_name);
+  odt->debug = parse_boolean (opt (d, o, "debug", "false"));
 
-  x->dirname = xstrdup ("odt-XXXXXX");
-  mkdtemp (x->dirname);
+  odt->dirname = xstrdup ("odt-XXXXXX");
+  mkdtemp (odt->dirname);
 
-  create_mimetype (x->dirname);
+  if (!create_mimetype (odt->dirname))
+    {
+      output_driver_destroy (d);
+      return NULL;
+    }
 
   /* Create the manifest */
-  x->manifest_wtr = create_writer (x, "META-INF/manifest.xml");
+  odt->manifest_wtr = create_writer (odt, "META-INF/manifest.xml");
 
-  xmlTextWriterStartElement (x->manifest_wtr, _xml("manifest:manifest"));
-  xmlTextWriterWriteAttribute (x->manifest_wtr, _xml("xmlns:manifest"),
+  xmlTextWriterStartElement (odt->manifest_wtr, _xml("manifest:manifest"));
+  xmlTextWriterWriteAttribute (odt->manifest_wtr, _xml("xmlns:manifest"),
 			       _xml("urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"));
 
 
   /* Add a manifest entry for the document as a whole */
-  xmlTextWriterStartElement (x->manifest_wtr, _xml("manifest:file-entry"));
-  xmlTextWriterWriteAttribute (x->manifest_wtr, _xml("manifest:media-type"),  _xml("application/vnd.oasis.opendocument.text"));
-  xmlTextWriterWriteAttribute (x->manifest_wtr, _xml("manifest:full-path"),  _xml("/"));
-  xmlTextWriterEndElement (x->manifest_wtr);
+  xmlTextWriterStartElement (odt->manifest_wtr, _xml("manifest:file-entry"));
+  xmlTextWriterWriteAttribute (odt->manifest_wtr, _xml("manifest:media-type"),  _xml("application/vnd.oasis.opendocument.text"));
+  xmlTextWriterWriteAttribute (odt->manifest_wtr, _xml("manifest:full-path"),  _xml("/"));
+  xmlTextWriterEndElement (odt->manifest_wtr);
 
 
-  write_meta_data (x);
+  write_meta_data (odt);
+  write_style_data (odt);
 
-  x->content_wtr = create_writer (x, "content.xml");
-  register_file (x, "content.xml");
+  odt->content_wtr = create_writer (odt, "content.xml");
+  register_file (odt, "content.xml");
 
 
   /* Some necessary junk at the start */
-  xmlTextWriterStartElement (x->content_wtr, _xml("office:document-content"));
-  xmlTextWriterWriteAttribute (x->content_wtr, _xml("xmlns:office"),
+  xmlTextWriterStartElement (odt->content_wtr, _xml("office:document-content"));
+  xmlTextWriterWriteAttribute (odt->content_wtr, _xml("xmlns:office"),
 			       _xml("urn:oasis:names:tc:opendocument:xmlns:office:1.0"));
 
-  xmlTextWriterWriteAttribute (x->content_wtr, _xml("xmlns:text"),
+  xmlTextWriterWriteAttribute (odt->content_wtr, _xml("xmlns:text"),
 			       _xml("urn:oasis:names:tc:opendocument:xmlns:text:1.0"));
 
-  xmlTextWriterWriteAttribute (x->content_wtr, _xml("xmlns:table"),
+  xmlTextWriterWriteAttribute (odt->content_wtr, _xml("xmlns:table"),
 			       _xml("urn:oasis:names:tc:opendocument:xmlns:table:1.0"));
 
-  xmlTextWriterWriteAttribute (x->content_wtr, _xml("office:version"), _xml("1.1"));
+  xmlTextWriterWriteAttribute (odt->content_wtr, _xml("office:version"), _xml("1.1"));
 
-  xmlTextWriterStartElement (x->content_wtr, _xml("office:body"));
-  xmlTextWriterStartElement (x->content_wtr, _xml("office:text"));
+  xmlTextWriterStartElement (odt->content_wtr, _xml("office:body"));
+  xmlTextWriterStartElement (odt->content_wtr, _xml("office:text"));
 
 
 
   /* Close the manifest */
-  xmlTextWriterEndElement (x->manifest_wtr);
-  xmlTextWriterEndDocument (x->manifest_wtr);
-  xmlFreeTextWriter (x->manifest_wtr);
+  xmlTextWriterEndElement (odt->manifest_wtr);
+  xmlTextWriterEndDocument (odt->manifest_wtr);
+  xmlFreeTextWriter (odt->manifest_wtr);
 
-  return true;
+  return d;
 }
 
-static bool
-odt_close_driver (struct outp_driver *this)
+static void
+odt_destroy (struct output_driver *driver)
 {
-  struct string zip_cmd;
-  struct string rm_cmd;
-  struct odt_driver_ext *x = this->ext;
-
-  xmlTextWriterEndElement (x->content_wtr); /* office:text */
-  xmlTextWriterEndElement (x->content_wtr); /* office:body */
-  xmlTextWriterEndElement (x->content_wtr); /* office:document-content */
-
-  xmlTextWriterEndDocument (x->content_wtr);
-  xmlFreeTextWriter (x->content_wtr);
-
-  /* Zip up the directory */
-  ds_init_empty (&zip_cmd);
-  ds_put_format (&zip_cmd, "cd %s ; rm -f ../pspp.odt; zip -q -X ../pspp.odt mimetype; zip -q -X -u -r ../pspp.odt .", x->dirname);
-  system (ds_cstr (&zip_cmd));
-  ds_destroy (&zip_cmd);
-
+  struct odt_driver *odt = odt_driver_cast (driver);
 
-  /* Remove the temp dir */
-  ds_init_empty (&rm_cmd);
-  ds_put_format (&rm_cmd, "rm -r %s", x->dirname);
-  system (ds_cstr (&rm_cmd));
-  ds_destroy (&rm_cmd);
-
-  free (x->dirname);
-  free (x);
-
-  return true;
-}
+  if (odt->content_wtr != NULL)
+    {
+      struct string zip_cmd;
+
+      xmlTextWriterEndElement (odt->content_wtr); /* office:text */
+      xmlTextWriterEndElement (odt->content_wtr); /* office:body */
+      xmlTextWriterEndElement (odt->content_wtr); /* office:document-content */
+
+      xmlTextWriterEndDocument (odt->content_wtr);
+      xmlFreeTextWriter (odt->content_wtr);
+
+      /* Zip up the directory */
+      ds_init_empty (&zip_cmd);
+      ds_put_format (&zip_cmd,
+                     "cd %s ; rm -f ../%s; zip -q -X ../%s mimetype; zip -q -X -u -r ../%s .",
+                     odt->dirname, odt->file_name, odt->file_name, odt->file_name);
+      system (ds_cstr (&zip_cmd));
+      ds_destroy (&zip_cmd);
+    }
 
-static void
-odt_open_page (struct outp_driver *this)
-{
-}
+  if ( !odt->debug )
+    {
+      /* Remove the temp dir */
+      struct string rm_cmd;
 
-static void
-odt_close_page (struct outp_driver *this)
-{
-}
+      ds_init_empty (&rm_cmd);
+      ds_put_format (&rm_cmd, "rm -r %s", odt->dirname);
+      system (ds_cstr (&rm_cmd));
+      ds_destroy (&rm_cmd);
+    }
+  else
+    fprintf (stderr, "Not removing directory %s\n", odt->dirname);
 
-static void
-odt_output_chart (struct outp_driver *this, const struct chart *chart)
-{
- printf ("%s\n", __FUNCTION__);
+  free (odt->command_name);
+  free (odt->dirname);
+  free (odt);
 }
 
-
-/* Submit a table to the ODT driver */
 static void
-odt_submit (struct outp_driver *this, struct som_entity *e)
+odt_submit_table (struct odt_driver *odt, struct table_item *item)
 {
+  const struct table *tab = table_item_get_table (item);
+  const char *caption = table_item_get_caption (item);
   int r, c;
-  
-  struct odt_driver_ext *x = this->ext;
-  struct tab_table *tab = e->ext;
-
 
   /* Write a heading for the table */
-  xmlTextWriterStartElement (x->content_wtr, _xml("text:h"));
-  xmlTextWriterWriteFormatAttribute (x->content_wtr, _xml("text:level"), "%d", e->subtable_num == 1 ? 2 : 3);
-  xmlTextWriterWriteString (x->content_wtr, _xml (tab->title) );
-  xmlTextWriterEndElement (x->content_wtr);
+  if (caption != NULL)
+    {
+      xmlTextWriterStartElement (odt->content_wtr, _xml("text:h"));
+      xmlTextWriterWriteFormatAttribute (odt->content_wtr, _xml("text:level"),
+                                         "%d", 2);
+      xmlTextWriterWriteString (odt->content_wtr,
+                                _xml (table_item_get_caption (item)) );
+      xmlTextWriterEndElement (odt->content_wtr);
+    }
 
   /* Start table */
-  xmlTextWriterStartElement (x->content_wtr, _xml("table:table"));
-  xmlTextWriterWriteFormatAttribute (x->content_wtr, _xml("table:name"), 
-				     "TABLE-%d.%d", e->table_num, e->subtable_num);
+  xmlTextWriterStartElement (odt->content_wtr, _xml("table:table"));
+  xmlTextWriterWriteFormatAttribute (odt->content_wtr, _xml("table:name"), 
+				     "TABLE-%d", odt->table_num++);
 
 
   /* Start column definitions */
-  xmlTextWriterStartElement (x->content_wtr, _xml("table:table-column"));
-  xmlTextWriterWriteFormatAttribute (x->content_wtr, _xml("table:number-columns-repeated"), "%d", tab->nc);
-  xmlTextWriterEndElement (x->content_wtr);
+  xmlTextWriterStartElement (odt->content_wtr, _xml("table:table-column"));
+  xmlTextWriterWriteFormatAttribute (odt->content_wtr, _xml("table:number-columns-repeated"), "%d", table_nc (tab));
+  xmlTextWriterEndElement (odt->content_wtr);
 
 
   /* Deal with row headers */
-  if ( tab->t > 0)
-    xmlTextWriterStartElement (x->content_wtr, _xml("table:table-header-rows"));
+  if ( table_ht (tab) > 0)
+    xmlTextWriterStartElement (odt->content_wtr, _xml("table:table-header-rows"));
     
 
   /* Write all the rows */
-  for (r = 0 ; r < tab->nr; ++r)
+  for (r = 0 ; r < table_nr (tab); ++r)
     {
-      int spanned_columns = 0;
       /* Start row definition */
-      xmlTextWriterStartElement (x->content_wtr, _xml("table:table-row"));
-
+      xmlTextWriterStartElement (odt->content_wtr, _xml("table:table-row"));
 
       /* Write all the columns */
-      for (c = 0 ; c < tab->nc ; ++c)
+      for (c = 0 ; c < table_nc (tab) ; ++c)
 	{
-	  char *s = NULL;
-	  unsigned int opts = tab->ct[tab->nc * r + c];
-	  struct substring ss = tab->cc[tab->nc * r + c];
+          struct table_cell cell;
 
-	  if (opts & TAB_EMPTY)
-	    {
-	      xmlTextWriterStartElement (x->content_wtr, _xml("table:table-cell"));
-	      xmlTextWriterEndElement (x->content_wtr);
-	      continue;
-	    }
+          table_get_cell (tab, c, r, &cell);
 
-	  if ( opts & TAB_JOIN)
-	    {
-	      if ( spanned_columns == 0)
-		{
-		  struct tab_joined_cell *j = (struct tab_joined_cell*) ss_data (ss);
-		  s = ss_xstrdup (j->contents);
-		}
-	    }
-	  else
-	    s = ss_xstrdup (ss);
+          if (c == cell.d[TABLE_HORZ][0] && r == cell.d[TABLE_VERT][0])
+            {
+              int colspan = table_cell_colspan (&cell);
+              int rowspan = table_cell_rowspan (&cell);
 
-	  if ( spanned_columns == 0 )
-	    {
-	      xmlTextWriterStartElement (x->content_wtr, _xml("table:table-cell"));
-	      xmlTextWriterWriteAttribute (x->content_wtr, _xml("office:value-type"), _xml("string"));
+              xmlTextWriterStartElement (odt->content_wtr, _xml("table:table-cell"));
+              xmlTextWriterWriteAttribute (odt->content_wtr, _xml("office:value-type"), _xml("string"));
 
-	      if ( opts & TAB_JOIN )
-		{
-		  struct tab_joined_cell *j = (struct tab_joined_cell*) ss_data (ss);
-		  spanned_columns = j->x2 - j->x1;
+              if (colspan > 1)
+                xmlTextWriterWriteFormatAttribute (
+                  odt->content_wtr, _xml("table:number-columns-spanned"),
+                  "%d", colspan);
 
-		  xmlTextWriterWriteFormatAttribute (x->content_wtr,
-						     _xml("table:number-columns-spanned"),
-						     "%d", spanned_columns);
-		}
+              if (rowspan > 1)
+                xmlTextWriterWriteFormatAttribute (
+                  odt->content_wtr, _xml("table:number-rows-spanned"),
+                  "%d", rowspan);
 
-	      xmlTextWriterStartElement (x->content_wtr, _xml("text:p"));
+	      xmlTextWriterStartElement (odt->content_wtr, _xml("text:p"));
 
-	      if ( r < tab->t || c < tab->l )
-		xmlTextWriterWriteAttribute (x->content_wtr, _xml("text:style-name"), _xml("Table_20_Heading"));
+	      if ( r < table_ht (tab) || c < table_hl (tab) )
+		xmlTextWriterWriteAttribute (odt->content_wtr, _xml("text:style-name"), _xml("Table_20_Heading"));
 	      else
-		xmlTextWriterWriteAttribute (x->content_wtr, _xml("text:style-name"), _xml("Table_20_Contents"));
+		xmlTextWriterWriteAttribute (odt->content_wtr, _xml("text:style-name"), _xml("Table_20_Contents"));
+
+	      xmlTextWriterWriteString (odt->content_wtr, _xml(cell.contents));
 
-	      xmlTextWriterWriteString (x->content_wtr, _xml (s));
-	  
-	      xmlTextWriterEndElement (x->content_wtr); /* text:p */
-	      xmlTextWriterEndElement (x->content_wtr); /* table:table-cell */
+	      xmlTextWriterEndElement (odt->content_wtr); /* text:p */
+	      xmlTextWriterEndElement (odt->content_wtr); /* table:table-cell */
 	    }
 	  else
 	    {
-	      xmlTextWriterStartElement (x->content_wtr, _xml("table:covered-table-cell"));
-	      xmlTextWriterEndElement (x->content_wtr);
-	      spanned_columns --;
+	      xmlTextWriterStartElement (odt->content_wtr, _xml("table:covered-table-cell"));
+	      xmlTextWriterEndElement (odt->content_wtr);
 	    }
 
-	  free (s);
+          table_cell_free (&cell);
 	}
   
-      xmlTextWriterEndElement (x->content_wtr); /* row */
+      xmlTextWriterEndElement (odt->content_wtr); /* row */
 
-      if ( tab->t > 0 && r == tab->t - 1)
-	xmlTextWriterEndElement (x->content_wtr); /* table-header-rows */
+      if ( table_ht (tab) > 0 && r == table_ht (tab) - 1)
+	xmlTextWriterEndElement (odt->content_wtr); /* table-header-rows */
     }
 
-  xmlTextWriterEndElement (x->content_wtr); /* table */
+  xmlTextWriterEndElement (odt->content_wtr); /* table */
 }
 
+static void
+odt_output_text (struct odt_driver *odt, const char *text)
+{
+  xmlTextWriterStartElement (odt->content_wtr, _xml("text:p"));
+  xmlTextWriterWriteString (odt->content_wtr, _xml(text));
+  xmlTextWriterEndElement (odt->content_wtr);
+}
 
-/* ODT driver class. */
-const struct outp_class odt_class =
+/* Submit a table to the ODT driver */
+static void
+odt_submit (struct output_driver *driver,
+            const struct output_item *output_item)
 {
-  "odf",
-  1,
+  struct odt_driver *odt = odt_driver_cast (driver);
 
-  odt_open_driver,
-  odt_close_driver,
+  output_driver_track_current_command (output_item, &odt->command_name);
 
-  odt_open_page,
-  odt_close_page,
-  NULL,
+  if (is_table_item (output_item))
+    odt_submit_table (odt, to_table_item (output_item));
+  else if (is_text_item (output_item))
+    {
+      /* XXX apply different styles based on text_item's type.  */
+      odt_output_text (odt, text_item_get_text (to_text_item (output_item)));
+    }
+  else if (is_message_item (output_item))
+    {
+      const struct message_item *message_item = to_message_item (output_item);
+      const struct msg *msg = message_item_get_msg (message_item);
+      char *s = msg_to_string (msg, odt->command_name);
+      odt_output_text (odt, s);
+      free (s);
+    }
+}
 
-  odt_output_chart,
-  odt_submit,
+struct output_driver_factory odt_driver_factory = { "odt", odt_create };
 
-  NULL,
-  NULL,
+static const struct output_driver_class odt_driver_class =
+{
+  "odf",
+  odt_destroy,
+  odt_submit,
   NULL,
 };