corinthia-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From g..@apache.org
Subject incubator-corinthia git commit: Add initial shape of ODF filter. Work-in-progress (compiles, tests, but does not run)
Date Thu, 23 Apr 2015 21:38:28 GMT
Repository: incubator-corinthia
Updated Branches:
  refs/heads/master 80abb7285 -> c4ea2ed93


Add initial shape of ODF filter.
Work-in-progress (compiles, tests, but does not run)

* DocFormats/core/src/xml/DFDOM.h

* DocFormats/filters/odf/src/text/ODFText.c
  (#include): Add new header file ODFPackage.h
  (ODFTextGet): New function.

* DocFormats/filters/ooxml/CMakeLists.txt
  (set): Add new group GROUPOOXMLODF.
  (add_library): Add new group GROUPOOXMLODF.
  (source_group): Add new directory 'odf' and  GROUPOOXMLODF.

* DocFormats/filters/ooxml/src/common/OOXMLTypedefs.h
  Copypasta and replace-string of Word related typedefs to 'ODFxxx'.
  Not clear they are all needed or correct.

* DocFormats/filters/ooxml/src/odf/: New directory.

* DocFormats/filters/ooxml/src/odf/ODFConverter.c: new file This file
   contains a lot of copy pasta.  Not sure what's needed, it's mostly
   commented out for now.  Probably contains a lot of incorrect things.

   (ODFConverterNew): New function.  Shell for now.
   (ODFConverterFree): New function.  Shell for now.
   (ODFConverterGet): New function.  Shell for now.

*  DocFormats/filters/ooxml/src/odf/ODFConverter.h: new file This file
   contains a lot of copy pasta.  Not sure what's needed, it's mostly
   commented out for now.  Probably contains a lot of incorrect things.


Project: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/commit/c4ea2ed9
Tree: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/tree/c4ea2ed9
Diff: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/diff/c4ea2ed9

Branch: refs/heads/master
Commit: c4ea2ed9389b46418eed7a1f499b8085461c58c3
Parents: 80abb72
Author: Gabriela Gibson <gbg@apache.org>
Authored: Thu Apr 23 21:40:12 2015 +0100
Committer: Gabriela Gibson <gbg@apache.org>
Committed: Thu Apr 23 21:40:12 2015 +0100

----------------------------------------------------------------------
 DocFormats/filters/odf/src/text/ODFText.c       |   31 +-
 DocFormats/filters/ooxml/CMakeLists.txt         |   11 +-
 .../filters/ooxml/src/common/OOXMLTypedefs.h    |   57 +
 DocFormats/filters/ooxml/src/odf/ODFConverter.c | 1083 ++++++++++++++++++
 DocFormats/filters/ooxml/src/odf/ODFConverter.h |  117 ++
 5 files changed, 1297 insertions(+), 2 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/c4ea2ed9/DocFormats/filters/odf/src/text/ODFText.c
----------------------------------------------------------------------
diff --git a/DocFormats/filters/odf/src/text/ODFText.c b/DocFormats/filters/odf/src/text/ODFText.c
index 0e13531..02ab2a9 100644
--- a/DocFormats/filters/odf/src/text/ODFText.c
+++ b/DocFormats/filters/odf/src/text/ODFText.c
@@ -17,10 +17,39 @@
 
 #include "DFPlatform.h"
 #include "ODFText.h"
+#include "ODFPackage.h"
 
 DFDocument *ODFTextGet(DFStorage *concreteStorage, DFStorage *abstractStorage, const char *idPrefix, DFError **error)
 {
-    DFErrorFormat(error,"ODFTextGet: Not yet implemented");
+    // DFErrorFormat(error,"ODFTextGet: Not yet implemented.");
+
+    int ok = 0;
+    ODFPackage *odfPackage = NULL;
+    DFDocument *htmlDoc = NULL;
+    
+    odfPackage = ODFPackageOpenFrom(concreteStorage,error);
+    if (odfPackage == NULL)
+        goto end;
+
+    htmlDoc = DFDocumentNew();
+
+    // WordConverterGet
+    if (!ODFConverterGet(htmlDoc,abstractStorage,odfPackage,idPrefix,error))
+        goto end;
+
+    ok = 1;
+
+end:
+    /*
+    ODFPackageRelease(odfPackage);
+    if (ok) {
+        return htmlDoc;
+    }
+    else {
+        DFDocumentRelease(htmlDoc);
+        return NULL;
+    }
+    */
     return NULL;
 }
 

http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/c4ea2ed9/DocFormats/filters/ooxml/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/DocFormats/filters/ooxml/CMakeLists.txt b/DocFormats/filters/ooxml/CMakeLists.txt
index 92f46f8..4696309 100644
--- a/DocFormats/filters/ooxml/CMakeLists.txt
+++ b/DocFormats/filters/ooxml/CMakeLists.txt
@@ -22,6 +22,13 @@ set(GroupOOXMLCommon
     src/common/OPC.h)
 
 
+###
+## group ooxml odf objects
+###
+set(GroupOOXMLODF
+    src/odf/ODFConverter.c
+    src/odf/ODFConverter.h)
+
 
 ###
 ## group ooxml word objects
@@ -152,11 +159,13 @@ add_library(ooxml OBJECT
     ${GroupOOXMLWord}
     ${GroupOOXMLWordFormatting}
     ${GroupOOXMLWordLenses}
-    ${GroupOOXMLWordTests})
+    ${GroupOOXMLWordTests}
+    ${GroupOOXMLODF})
 
 source_group(src\\common           FILES ${GroupOOXMLCommon})
 source_group(src\\word             FILES ${GroupOOXMLWord})
 source_group(src\\word\\formatting FILES ${GroupOOXMLWordFormatting})
 source_group(src\\word\\lenses     FILES ${GroupOOXMLWordLenses})
 source_group(tests\\word           FILES ${GroupOOXMLWordTests})
+source_group(src\\odf              FILES ${GroupOOXMLODF})
 set_property(TARGET ooxml PROPERTY FOLDER DocFormats/filters)

http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/c4ea2ed9/DocFormats/filters/ooxml/src/common/OOXMLTypedefs.h
----------------------------------------------------------------------
diff --git a/DocFormats/filters/ooxml/src/common/OOXMLTypedefs.h b/DocFormats/filters/ooxml/src/common/OOXMLTypedefs.h
index 61d8cbb..a4f2553 100644
--- a/DocFormats/filters/ooxml/src/common/OOXMLTypedefs.h
+++ b/DocFormats/filters/ooxml/src/common/OOXMLTypedefs.h
@@ -70,4 +70,61 @@ typedef struct WordDrawing WordDrawing;
 // word/lenses/WordLenses.h
 typedef struct WordLens WordLens;
 
+
+//////////////////////////////////////////////////////////////////
+// ODF experiment... ignore this for now. 
+//////////////////////////////////////////////////////////////////
+// ODF/OPC.h
+typedef struct OPCRelationship OPCRelationship;
+typedef struct OPCRelationshipSet OPCRelationshipSet;
+typedef struct OPCPart OPCPart;
+typedef struct OPCContentTypes OPCContentTypes;
+typedef struct OPCPackage OPCPackage;
+
+// ODF/ODFCaption.h
+typedef struct ODFCaption ODFCaption;
+
+// ODF/ODFConverter.h
+typedef struct ODFGetData ODFGetData;
+typedef struct ODFPutData ODFPutData;
+typedef struct ODFConverter ODFConverter;
+
+// ODF/ODFNotes.h
+typedef struct ODFNote ODFNote;
+typedef struct ODFNoteGroup ODFNoteGroup;
+
+// ODF/ODFNumbering.h
+typedef struct ODFNumLevel ODFNumLevel;
+typedef struct ODFAbstractNum ODFAbstractNum;
+typedef struct ODFConcreteNum ODFConcreteNum;
+typedef struct ODFNumbering ODFNumbering;
+
+// ODF/ODFObjects.h
+typedef struct ODFObjects ODFObjects;
+
+// ODF/ODFPackage.h
+typedef struct ODFPackage ODFPackage;
+
+// ODF/ODFSection.h
+typedef struct ODFSection ODFSection;
+
+// ODF/ODFSheet.h
+typedef struct ODFStyle ODFStyle;
+typedef struct ODFSheet ODFSheet;
+
+// ODF/ODFTheme.h
+typedef struct ODFTheme ODFTheme;
+
+// ODF/lenses/ODFBookmark.h
+typedef enum ODFBookmarkType ODFBookmarkType;
+typedef struct CaptionParts CaptionParts;
+typedef struct ODFBookmark ODFBookmark;
+
+// ODF/lenses/ODFDrawing.h
+typedef struct ODFDrawing ODFDrawing;
+
+// ODF/lenses/ODFLenses.h
+typedef struct ODFLens ODFLens;
+
+
 #endif

http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/c4ea2ed9/DocFormats/filters/ooxml/src/odf/ODFConverter.c
----------------------------------------------------------------------
diff --git a/DocFormats/filters/ooxml/src/odf/ODFConverter.c b/DocFormats/filters/ooxml/src/odf/ODFConverter.c
new file mode 100644
index 0000000..c7d79e8
--- /dev/null
+++ b/DocFormats/filters/ooxml/src/odf/ODFConverter.c
@@ -0,0 +1,1083 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "DFPlatform.h"
+#include "ODFConverter.h"
+/*
+#include "WordBookmark.h"
+#include "WordField.h"
+#include "WordStyles.h"
+#include "WordSheet.h"
+#include "WordNotes.h"
+#include "WordNumbering.h"
+#include "WordSection.h"
+#include "WordSettings.h"
+#include "WordObjects.h"
+#include "WordLists.h"
+#include "WordGC.h"
+#include "WordLenses.h"
+#include "WordCaption.h"
+#include "WordWhitespace.h"
+#include "WordTheme.h"
+*/
+#include "OPC.h"
+#include "DFDOM.h"
+#include "DFHTML.h"
+#include "DFHTMLNormalization.h"
+#include "DFBDT.h"
+#include "CSS.h"
+#include "CSSProperties.h"
+#include "CSSLength.h"
+#include "CSSSelector.h"
+#include "CSSClassNames.h"
+#include "CSSSheet.h"
+#include "CSSStyle.h"
+#include "DFXML.h"
+#include "DFString.h"
+#include "DFCharacterSet.h"
+#include "DFCommon.h"
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+static int isWhitespaceRun(DFNode *run)
+{
+    for (DFNode *child = run->first; child != NULL; child = child->next) {
+        switch (child->tag) {
+            case WORD_RPR:
+                break;
+            case WORD_T: {
+                char *str = DFNodeTextToString(child);
+                int isWhitespace = DFStringIsWhitespace(str);
+                free(str);
+                if (!isWhitespace)
+                    return 0;
+                break;
+            }
+            default:
+                return 0;
+        }
+    }
+    return 1;
+}
+*/
+/*
+int Word_isFigureParagraph(DFNode *p)
+{
+    // A paragraph is a figure if it contains only a single run, and that run contains a drawing
+    if ((p == NULL) || (p->tag != WORD_P))
+        return 0;;
+
+    DFNode *run = NULL;
+    int runCount = 0;
+    for (DFNode *child = p->first; child != NULL; child = child->next) {
+        if (child->tag == WORD_R) {
+            if (isWhitespaceRun(child))
+                continue;
+            run = child;
+            runCount++;
+        }
+    }
+
+    if (runCount != 1)
+        return 0;
+
+    for (DFNode *child = run->first; child != NULL; child = child->next) {
+        switch (child->tag) {
+            case WORD_DRAWING:
+            case WORD_OBJECT:
+            case WORD_PICT:
+                return 1;
+        }
+    }
+
+    return 0;
+}
+
+int Word_isEquationParagraph(DFNode *p)
+{
+    if ((p == NULL) || (p->tag != WORD_P))
+        return 0;
+
+    for (DFNode *child = p->first; child != NULL; child = child->next) {
+        if (child->tag == MATH_OMATHPARA)
+            return 1;
+    }
+
+    return 0;
+}
+
+static int attributesEqual(DFNode *elemA, DFNode *elemB)
+{
+    if (elemA->attrsCount != elemB->attrsCount)
+        return 0;
+
+    int count = elemA->attrsCount;
+    for (int ai = 0; ai < count; ai++) {
+        DFAttribute *attrA = &elemA->attrs[ai];
+        int found = 0;
+        for (int bi = 0; bi < count; bi++) {
+            DFAttribute *attrB = &elemB->attrs[bi];
+            if (attrA->tag == attrB->tag) {
+                if (strcmp(attrA->value,attrB->value))
+                    return 0;
+                found = 1;
+                break;
+            }
+        }
+        if (!found)
+            return 0;
+    }
+
+    return 1;
+}
+
+static int nodesEqual(DFNode *a, DFNode *b)
+{
+    if ((a == NULL) && (b == NULL))
+        return 1;
+
+    if ((a == NULL) || (b == NULL))
+        return 0;
+
+    if (a->tag != b->tag)
+        return 0;
+
+    if (a->tag < MIN_ELEMENT_TAG)
+        return 0;;
+
+    // First check if the number and type of children are the same
+    DFNode *aChild = a->first;
+    DFNode *bChild = b->first;
+    while ((aChild != NULL) || (bChild != NULL)) {
+        if ((aChild != NULL) && (bChild == NULL))
+            return 0;
+        if ((aChild == NULL) && (bChild != NULL))
+            return 0;
+        if (aChild->tag != bChild->tag)
+            return 0;
+        aChild = aChild->next;
+        bChild = bChild->next;
+    }
+
+    // Next check the attributes
+    if (!attributesEqual(a,b))
+        return 0;
+
+    // Now check the *content* of the children. We do this after the above as it is more expensive.
+    aChild = a->first;
+    bChild = b->first;
+    while ((aChild != NULL) || (bChild != NULL)) {
+        if (!nodesEqual(aChild,bChild))
+            return 0;
+        aChild = aChild->next;
+        bChild = bChild->next;
+    }
+    return 1;
+}
+
+static void Word_mergeRunsRecursive(DFNode *node)
+{
+    DFNode *current = node->first;
+    while (current != NULL) {
+        DFNode *next = current->next;
+
+        if ((current->tag == WORD_R) && (next != NULL) && (next->tag == WORD_R)) {
+            DFNode *currentRPr = DFChildWithTag(current,WORD_RPR);
+            DFNode *nextRPr = DFChildWithTag(next,WORD_RPR);
+            if (nodesEqual(currentRPr,nextRPr)) {
+                while (next->first != NULL) {
+                    if (next->first->tag == WORD_RPR)
+                        DFRemoveNode(next->first);
+                    else
+                        DFAppendChild(current,next->first);
+                }
+                DFRemoveNode(next);
+                continue;
+            }
+        }
+
+        current = next;
+    }
+
+    for (current = node->first; current != NULL; current = current->next)
+        Word_mergeRunsRecursive(current);
+}
+
+static void Word_mergeRuns(WordPackage *package)
+{
+    if (package->document != NULL)
+        Word_mergeRunsRecursive(package->document->docNode);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//                                                                                                //
+//                                  HTML pre- and post-processing                                 //
+//                                                                                                //
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+static void Word_addContentParts(DFNode *child, const char *content, WordCaption *caption)
+{
+    if (content == NULL)
+        return;;
+    DFNode *nextSibling = child->first;
+    DFArray *parts = CSSParseContent(content);
+    for (size_t i = 0; i < DFArrayCount(parts); i++) {
+        ContentPart *part = DFArrayItemAt(parts,i);
+        switch (part->type) {
+            case ContentPartString: {
+                DFNode *text = DFCreateTextNode(child->doc,part->value);
+                if (strlen(part->value) > 0) {
+                    DFNode *span = DFCreateElement(child->doc,HTML_SPAN);
+                    DFAppendChild(span,text);
+                    DFInsertBefore(child,span,nextSibling);
+                }
+                break;
+            }
+            case ContentPartCounter: {
+                if (DFStringEquals(part->value,"figure")) {
+                    DFNode *span = DFCreateElement(child->doc,HTML_SPAN);
+                    DFSetAttribute(span,HTML_CLASS,DFFieldClass);
+                    DFCreateChildTextNode(span," SEQ Figure \\* ARABIC ");
+                    DFInsertBefore(child,span,nextSibling);
+                    caption->number = span;
+                }
+                else if (DFStringEquals(part->value,"table")) {
+                    DFNode *span = DFCreateElement(child->doc,HTML_SPAN);
+                    DFSetAttribute(span,HTML_CLASS,DFFieldClass);
+                    DFCreateChildTextNode(span," SEQ Table \\* ARABIC ");
+                    DFInsertBefore(child,span,nextSibling);
+                    caption->number = span;
+                }
+                break;
+            default:
+                break;
+            }
+        }
+    }
+    DFArrayRelease(parts);
+}
+
+static void Word_preProcessHTML(WordConverter *word, DFNode *node)
+{
+    switch (node->tag) {
+        case HTML_TABLE:
+        case HTML_FIGURE: {
+            DFNode *next;
+            for (DFNode *child = node->first; child != NULL; child = next) {
+                next = child->next;
+
+                if ((child->tag != HTML_CAPTION) && (child->tag != HTML_FIGCAPTION))
+                    continue;
+
+                WordCaption *caption = WordCaptionNew(child);
+                WordObjectsSetCaption(word->objects,caption,node);
+                caption->contentStart = child->first;
+                WordCaptionRelease(caption);
+
+                const char *className = DFGetAttribute(child,HTML_CLASS);
+                CSSStyle *style;
+                if (child->tag == HTML_CAPTION)
+                    style = CSSSheetLookupElement(word->styleSheet,"caption",className,0,0);
+                else
+                    style = CSSSheetLookupElement(word->styleSheet,"figcaption",className,0,0);
+
+                CSSProperties *before = CSSStyleBefore(style);
+                if (CSSGet(before,"content") != NULL)
+                    Word_addContentParts(child,CSSGet(before,"content"),caption);
+
+                child->tag = HTML_P;
+                DFSetAttribute(child,HTML_CLASS,"Caption");
+                DFInsertBefore(node->parent,child,node->next);
+                Word_preProcessHTML(word,child);
+            }
+
+            // The HTML normalization process ensures that apart from the <figcaption> element,
+            // all children of a <figure> are paragraphs or containers. Currently the editor only
+            // lets you create figures that contain a single image, so it's always a single
+            // paragraph. Since the HTML <figure> element gets mapped to a single <w:p> element
+            // by WordParagraphLens, we want to make sure it only contains inline children.
+
+            for (DFNode *child = node->first; child != NULL; child = next) {
+                next = child->next;
+                if (HTML_isParagraphTag(child->tag))
+                    DFRemoveNodeButKeepChildren(child);
+            }
+
+            // FIXME: Handle <div>, <pre>, lists, tables etc which could also theoretically
+            // exist inside the <figure> element
+
+            break;
+        }
+        case HTML_NAV: {
+            const char *className = DFGetAttribute(node,HTML_CLASS);
+            const char *instr = NULL;
+            if (DFStringEquals(className,DFTableOfContentsClass))
+                instr = " TOC \\o \"1-3\" ";
+            else if (DFStringEquals(className,DFListOfFiguresClass))
+                instr = " TOC \\c \"Figure\" ";
+            else if (DFStringEquals(className,DFListOfTablesClass))
+                instr = " TOC \\c \"Table\" ";
+
+            if (instr != NULL) {
+                DFNode *p = DFCreateElement(word->html,HTML_P);
+                DFNode *field = DFCreateChildElement(p,HTML_SPAN);
+                DFSetAttribute(field,HTML_CLASS,DFFieldClass);
+                DFCreateChildTextNode(field,instr);
+                DFInsertBefore(node->parent,p,node);
+                DFRemoveNode(node);
+            }
+            break;
+        }
+    }
+
+    DFNode *next;
+    for (DFNode *child = node->first; child != NULL; child = next) {
+        next = child->next;
+        Word_preProcessHTML(word,child);
+    }
+}
+
+static void Word_preProcessHTMLDoc(WordConverter *word, DFDocument *doc)
+{
+    WordPreProcessHTMLLists(word);
+    Word_preProcessHTML(word,doc->docNode);
+}
+
+static int isSeqField(DFNode *node)
+{
+    if (node->tag != HTML_SPAN)
+        return 0;
+    if (!DFStringEquals(DFGetAttribute(node,HTML_CLASS),DFFieldClass))
+        return 0;
+    char *instr = DFNodeTextToString(node);
+    const char **args = Word_parseField(instr);
+    int result = (args[0] != NULL) && !strcmp(args[0],"SEQ");
+    free(args);
+    free(instr);
+    return result;
+}
+
+static DFNode *findSeqChild(DFNode *parent)
+{
+    for (DFNode *child = parent->first; child != NULL; child = child->next) {
+        if (isSeqField(child))
+            return child;;
+        DFNode *result = findSeqChild(child);
+        if (result != NULL)
+            return result;
+    }
+    return NULL;
+}
+
+static void extractPrefixRecursive(DFNode *node, const char *counterName, DFBuffer *result,
+                                   int *foundSeq, int *foundContent)
+{
+    if (isSeqField(node)) {
+        if (result->len > 0)
+            DFBufferFormat(result," ");
+        DFBufferFormat(result,"counter(%s)",counterName);
+        *foundSeq = 1;
+        DFRemoveNode(node);
+        return;
+    }
+
+    if (node->tag == DOM_TEXT) {
+        size_t valueLen = strlen(node->value);
+        size_t pos = 0;
+
+        if (*foundSeq) {
+            size_t offset = 0;
+            uint32_t ch;
+            do {
+                pos = offset;
+                ch = DFNextChar(node->value,&offset);
+            } while ((ch != 0) && (DFCharIsWhitespaceOrNewline(ch) || DFCharIsPunctuation(ch)));
+        }
+        else {
+            pos = valueLen;
+        }
+
+        if (pos == valueLen) {
+            if (result->len > 0)
+                DFBufferFormat(result," ");
+            char *quotedValue = DFQuote(node->value);
+            DFBufferFormat(result,"%s",quotedValue);
+            free(quotedValue);
+            DFRemoveNode(node);
+            if (*foundSeq)
+                *foundContent = 1;
+            return;
+        }
+        else if (pos > 0) {
+            char *first = DFSubstring(node->value,0,pos);
+            char *rest = DFSubstring(node->value,pos,valueLen);
+            if (result->len > 0)
+                DFBufferFormat(result," ");
+            char *quotedFirst = DFQuote(first);
+            DFBufferFormat(result,"%s",quotedFirst);
+            free(quotedFirst);
+            DFSetNodeValue(node,rest);
+            if (*foundSeq)
+                *foundContent = 1;
+            free(first);
+            free(rest);
+            return;
+        }
+    }
+
+    int wasEmpty = (node->first == NULL);
+    DFNode *next;
+    for (DFNode *child = node->first; child != NULL; child = next) {
+        next = child->next;
+        if (*foundContent)
+            break;
+        extractPrefixRecursive(child,counterName,result,foundSeq,foundContent);
+    }
+    int isEmpty = (node->first == NULL);
+    if ((node->tag == HTML_SPAN) && isEmpty && !wasEmpty)
+        DFRemoveNode(node);
+}
+
+static char *extractPrefix(DFNode *node, const char *counterName)
+{
+    if (findSeqChild(node) == NULL)
+        return NULL;;
+    DFBuffer *result = DFBufferNew();
+    int foundSeq = 0;
+    int foundContent = 0;
+    extractPrefixRecursive(node,counterName,result,&foundSeq,&foundContent);
+    char *str = xstrdup(result->data);
+    DFBufferRelease(result);
+    return str;
+}
+
+static void Word_postProcessHTML(WordConverter *conv, DFNode *node)
+{
+    DFNode *next;
+    for (DFNode *child = node->first; child != NULL; child = next) {
+        next = child->next;
+
+        switch (child->tag) {
+            case HTML_SPAN: {
+                const char *className = DFGetAttribute(child,HTML_CLASS);
+                if (DFStringEquals(className,DFBookmarkClass)) {
+                    if (child->first != NULL)
+                        next = child->first;
+                    DFRemoveNodeButKeepChildren(child);
+                }
+                break;
+            }
+            case HTML_CAPTION: {
+                const char *counterName = NULL;
+
+                if ((child->prev != NULL) && (child->prev->tag == HTML_FIGURE) &&
+                    (DFChildWithTag(child->prev,HTML_FIGCAPTION) == NULL)) {
+                    child->tag = HTML_FIGCAPTION;
+                    counterName = "figure";
+                    DFAppendChild(child->prev,child);
+                }
+                else if ((child->prev != NULL) && (child->prev->tag == HTML_TABLE) &&
+                         (DFChildWithTag(child->prev,HTML_CAPTION) == NULL)) {
+                    counterName = "table";
+                    DFInsertBefore(child->prev,child,child->prev->first);
+                }
+                else if ((child->next != NULL) && (child->next->tag == HTML_FIGURE) &&
+                         (DFChildWithTag(child->next,HTML_FIGCAPTION) == NULL)) {
+                    child->tag = HTML_FIGCAPTION;
+                    counterName = "figure";
+                    DFInsertBefore(child->next,child,child->next->first);
+                }
+                else if ((child->next != NULL) && (child->next->tag == HTML_TABLE) &&
+                         (DFChildWithTag(child->next,HTML_CAPTION) == NULL)) {
+                    counterName = "table";
+                    DFSetAttribute(child,HTML_STYLE,"caption-side: top");
+                    DFInsertBefore(child->next,child,child->next->first);
+                }
+
+                if (counterName != NULL) {
+                    char *beforeText = extractPrefix(child,counterName);
+                    if (beforeText != NULL) {
+                        CSSStyle *style = CSSSheetLookupElement(conv->styleSheet,DFNodeName(child),NULL,1,0);
+                        if (CSSGet(CSSStyleBefore(style),"content") == NULL) {
+                            CSSPut(CSSStyleRule(style),"counter-increment",counterName);
+                            CSSPut(CSSStyleBefore(style),"content",beforeText);
+                        }
+                    }
+                    free(beforeText);
+                }
+                break;
+            }
+            case HTML_NAV: {
+                if (HTML_isParagraphTag(node->tag)) {
+
+                    if (child->prev != NULL) {
+                        DFNode *beforeP = DFCreateElement(conv->html,node->tag);
+                        while (child->prev != NULL)
+                            DFInsertBefore(beforeP,child->prev,beforeP->first);
+                        DFInsertBefore(node->parent,beforeP,node);
+                    }
+                    DFInsertBefore(node->parent,child,node);
+
+                    if ((node->first == NULL) ||
+                        ((node->first->tag == HTML_BR) && (node->first->next == NULL))) {
+                        DFRemoveNode(node);
+                        return;
+                    }
+                    next = NULL;
+                }
+                break;
+            }
+        }
+    }
+
+    for (DFNode *child = node->first; child != NULL; child = next) {
+        next = child->next;
+        Word_postProcessHTML(conv,child);
+    }
+}
+
+static void Word_postProcessHTMLDoc(WordConverter *conv)
+{
+    WordPostProcessHTMLLists(conv);
+    Word_postProcessHTML(conv,conv->html->docNode);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//                                                                                                //
+//                                          WordConverter                                         //
+//                                                                                                //
+////////////////////////////////////////////////////////////////////////////////////////////////////
+*/
+static ODFConverter *ODFConverterNew(DFDocument *html, DFStorage *abstractStorage, ODFPackage *package, const char *idPrefix)
+{
+    ODFConverter *converter = (ODFConverter *)xcalloc(1,sizeof(ODFConverter));
+    converter->html = DFDocumentRetain(html);
+    converter->abstractStorage = DFStorageRetain(abstractStorage);
+    assert(DFStorageFormat(converter->abstractStorage) == DFFileFormatHTML);
+    /*
+    converter->idPrefix = (idPrefix != NULL) ? xstrdup(idPrefix) : xstrdup("word");
+    converter->package = WordPackageRetain(package);
+    converter->styles = WordSheetNew(converter->package->styles);
+    converter->numbering = WordNumberingNew(converter->package);
+    converter->theme = WordThemeNew(converter->package);
+    converter->mainSection = WordSectionNew();
+    converter->objects = WordObjectsNew(converter->package);
+    converter->footnotes = WordNoteGroupNewFootnotes(converter->package->footnotes);
+    converter->endnotes = WordNoteGroupNewEndnotes(converter->package->endnotes);
+    converter->supportedContentTypes = DFHashTableNew((DFCopyFunction)xstrdup,free);
+    */
+    DFHashTableAdd(converter->supportedContentTypes,"jpg","image/jpeg");
+    DFHashTableAdd(converter->supportedContentTypes,"jpeg","image/jpeg");
+    DFHashTableAdd(converter->supportedContentTypes,"tif","image/tiff");
+    DFHashTableAdd(converter->supportedContentTypes,"tiff","image/tiff");
+    DFHashTableAdd(converter->supportedContentTypes,"gif","image/gif");
+    DFHashTableAdd(converter->supportedContentTypes,"bmp","image/bmp");
+    DFHashTableAdd(converter->supportedContentTypes,"png","image/png");
+    
+    converter->warnings = DFBufferNew();
+    return converter;
+}
+
+static void ODFConverterFree(ODFConverter *converter)
+{
+    DFDocumentRelease(converter->html);
+    DFStorageRelease(converter->abstractStorage);
+    free(converter->idPrefix);
+    /*
+    WordSheetFree(converter->styles);
+    WordNumberingFree(converter->numbering);
+    WordThemeFree(converter->theme);
+    WordSectionFree(converter->mainSection);
+    WordObjectsFree(converter->objects);
+    WordNoteGroupRelease(converter->footnotes);
+    WordNoteGroupRelease(converter->endnotes);
+    DFHashTableRelease(converter->supportedContentTypes);
+    DFBufferRelease(converter->warnings);
+    CSSSheetRelease(converter->styleSheet);
+    WordPackageRelease(converter->package);
+    */
+    free(converter);
+}
+/*
+DFNode *WordConverterCreateAbstract(WordGetData *get, Tag tag, DFNode *concrete)
+{
+    DFNode *element = DFCreateElement(get->conv->html,tag);
+    if (concrete != NULL) {
+        char *idStr;
+        if (concrete->doc == get->conv->package->document)
+            idStr = DFFormatString("%s%u",get->conv->idPrefix,concrete->seqNo);
+        else
+            idStr = DFFormatString("%s%u-%s",get->conv->idPrefix,concrete->seqNo,DFNodeName(concrete->doc->root));
+        DFSetAttribute(element,HTML_ID,idStr);
+        free(idStr);
+    }
+    return element;
+}
+
+DFNode *WordConverterGetConcrete(WordPutData *put, DFNode *abstract)
+{
+    // Is the abstract node an element, and does it have an id that matches the prefix used for
+    // conversion? That is, does it look like it has a corresponding node in the concrete document?
+    if ((abstract == NULL) || (abstract->tag < MIN_ELEMENT_TAG))
+        return NULL;;
+    const char *idStr = DFGetAttribute(abstract,HTML_ID);
+    if ((idStr == NULL) || !DFStringHasPrefix(idStr,put->conv->idPrefix))
+        return NULL;;
+
+    // Determine the node sequence number and the document based on the id attribute.
+    // The format of the attribute is <prefix><seqno>(-<docname>)?, where
+    //
+    //     <prefix>  is the BDT prefix we use to identify nodes that match the original document
+    //     <seqno>   is an integer uniquely identifying a node in a given document
+    //     <docname> is the name of the document, either footnotes or endnotes. If absent, it is
+    //               the main content document (that is, document.xml)
+    //
+    // Note that the sequence number only makes sense within the context of a specific document. It
+    // is possible to have two different nodes in different documents that have the same sequence number.
+    // It is for this reason that the id string identifies both the node and the document.
+
+    size_t idLen = strlen(idStr);
+    size_t prefixLen = strlen(put->conv->idPrefix);
+
+    unsigned int seqNo = 0;
+    size_t pos = prefixLen;
+    while ((pos < idLen) && (idStr[pos] >= '0') && (idStr[pos] <= '9'))
+        seqNo = seqNo*10 + (idStr[pos++] - '0');
+
+    const char *docName = NULL;
+    if ((pos < idLen) && (idStr[pos] == '-')) {
+        pos++;
+        docName = &idStr[pos];
+    }
+
+    DFDocument *doc = NULL;
+    if (docName == NULL)
+        doc = put->conv->package->document;
+    else if (!strcmp(docName,"footnotes"))
+        doc = put->conv->package->footnotes;
+    else if (!strcmp(docName,"endnotes"))
+        doc = put->conv->package->endnotes;
+    else
+        return NULL;
+
+    // Check to see if we have a node in the concrete document matching that sequence number
+    DFNode *node = DFNodeForSeqNo(doc,seqNo);
+
+    // Only return the node if it's actually an element
+    if ((node == NULL) || (node->tag < MIN_ELEMENT_TAG))
+        return NULL;
+    return node;
+}
+*/
+
+int ODFConverterGet(DFDocument *html, DFStorage *abstractStorage, ODFPackage *package, const char *idPrefix, DFError **error)
+{
+    // 1i: contentDoc is a crude guess here.
+    if (package->contentDoc == NULL) {
+        DFErrorFormat(error,"document.xml not found");
+        return 0;
+    }
+    
+    // 1i: asssuming that OFFIC means AOO and so the WORD_DOCUMENT equivalent is OFFICE_DOCUMENT
+    DFNode *odfDocument = DFChildWithTag(package->contentDoc->docNode,OFFICE_DOCUMENT);
+    if (odfDocument == NULL) {
+        DFErrorFormat(error,"odf:document not found");
+        return 0;
+    }
+    /*
+    int haveFields = Word_simplifyFields(package);
+    Word_mergeRuns(package);
+
+    WordConverter *converter = WordConverterNew(html,abstractStorage,package,idPrefix);
+    converter->haveFields = haveFields;
+    WordAddNbsps(converter->package->document);
+    WordFixLists(converter);
+
+    CSSSheetRelease(converter->styleSheet);
+    converter->styleSheet = WordParseStyles(converter);
+    WordObjectsCollapseBookmarks(converter->objects);
+    WordObjectsScan(converter->objects);
+    WordObjectsAnalyzeBookmarks(converter->objects,converter->styles);
+
+    WordGetData get;
+    get.conv = converter;
+    DFNode *abstract = WordDocumentLens.get(&get,wordDocument);
+    DFAppendChild(converter->html->docNode,abstract);
+    converter->html->root = abstract;
+    Word_postProcessHTMLDoc(converter);
+
+    HTMLAddExternalStyleSheet(converter->html,"reset.css");
+    char *cssText = CSSSheetCopyCSSText(converter->styleSheet);
+    HTMLAddInternalStyleSheet(converter->html,cssText);
+    free(cssText);
+
+    HTML_safeIndent(converter->html->docNode,0);
+    */
+    int ok = 1;
+    /* if (converter->warnings->len > 0) { */
+    /*     DFErrorFormat(error,"%s",converter->warnings->data); */
+    /*     ok = 0; */
+    /* } */
+
+    /* ODFConverterFree(converter); */
+    return ok;
+}
+/*
+static void buildListMapFromHTML(WordPutData *put, DFNode *node)
+{
+    if (node->tag == HTML_P) {
+        const char *htmlId = DFGetAttribute(node,CONV_LISTNUM);
+        DFNode *conElem = (htmlId != NULL) ? WordConverterGetConcrete(put,node) : NULL;
+        DFNode *pPrElem = (conElem != NULL) ? DFChildWithTag(conElem,WORD_PPR) : NULL;
+        DFNode *numPrElem = (pPrElem != NULL) ? DFChildWithTag(pPrElem,WORD_NUMPR) : NULL;
+        DFNode *numIdElem = (numPrElem != NULL) ? DFChildWithTag(numPrElem,WORD_NUMID) : NULL;
+        const char *numId = (numIdElem != NULL) ? DFGetAttribute(numIdElem,WORD_VAL) : NULL;
+
+        if (numId != NULL) {
+            const char *existingHtmlId = DFHashTableLookup(put->htmlIdByNumId,numId);
+            const char *existingNumId = DFHashTableLookup(put->numIdByHtmlId,htmlId);
+            if ((existingHtmlId == NULL) && (existingNumId == NULL)) {
+                DFHashTableAdd(put->htmlIdByNumId,numId,htmlId);
+                DFHashTableAdd(put->numIdByHtmlId,htmlId,numId);
+
+                WordConcreteNum *num = WordNumberingConcreteWithId(put->conv->numbering,numId);
+                if (num != NULL)
+                    num->referenceCount++;
+            }
+        }
+    }
+
+    for (DFNode *child = node->first; child != NULL; child = child->next)
+        buildListMapFromHTML(put,child);
+}
+
+static void updateListTypes(WordPutData *put)
+{
+    const char **htmlIds = DFHashTableCopyKeys(put->numIdByHtmlId);
+    for (int i = 0; htmlIds[i]; i++) {
+        const char *htmlId = htmlIds[i];
+        const char *numId = DFHashTableLookup(put->numIdByHtmlId,htmlId);
+        WordConcreteNum *num = WordNumberingConcreteWithId(put->conv->numbering,numId);
+        if (num == NULL)
+            continue; // FIXME: remove entry from both maps so it is re-created
+        DFNode *listNode = DFNodeForSeqNo(put->conv->html,(unsigned int)atoi(htmlId));
+        assert(listNode != NULL);
+
+        const char *htmlType = DFGetAttribute(listNode,CONV_LISTTYPE);
+        const char *htmlIlvl = DFGetAttribute(listNode,CONV_ILVL);
+
+        WordNumLevel *level = WordConcreteNumGetLevel(num,atoi(htmlIlvl));
+        if (level == NULL)
+            continue; // FIXME: remove entry from both maps so it is re-created
+
+        const char *wordType = WordNumLevelToListStyleType(level);
+
+        if (!DFStringEquals(wordType,htmlType)) {
+            // Make a copy of numId, as it may be freed during the first call to DFHashTableRemove
+            char *numIdCopy = xstrdup(numId);
+            DFHashTableRemove(put->numIdByHtmlId,htmlId);
+            DFHashTableRemove(put->htmlIdByNumId,numIdCopy);
+            free(numIdCopy);
+            if (num->referenceCount == 1)
+                WordNumberingRemoveConcrete(put->conv->numbering,num);
+        }
+    }
+    free(htmlIds);
+}
+
+static void addMissingDefaultStyles(WordConverter *converter)
+{
+    if (CSSSheetDefaultStyleForFamily(converter->styleSheet,StyleFamilyParagraph) == NULL) {
+        CSSStyle *style = CSSSheetLookupElement(converter->styleSheet,"p","Normal",1,0);
+        CSSSheetSetDefaultStyle(converter->styleSheet,style,StyleFamilyParagraph);
+    }
+    if (CSSSheetDefaultStyleForFamily(converter->styleSheet,StyleFamilyCharacter) == NULL) {
+        CSSStyle *style = CSSSheetLookupElement(converter->styleSheet,"span","DefaultParagraphFont",1,0);
+        CSSStyleSetDisplayName(style,"Default Paragraph Font");
+        CSSSheetSetDefaultStyle(converter->styleSheet,style,StyleFamilyCharacter);
+    }
+    if (CSSSheetDefaultStyleForFamily(converter->styleSheet,StyleFamilyTable) == NULL) {
+        CSSStyle *style = CSSSheetLookupElement(converter->styleSheet,"table","Normal_Table",1,0);
+        CSSStyleSetDisplayName(style,"Normal Table");
+        CSSPut(CSSStyleCell(style),"padding-left","5.4pt");
+        CSSPut(CSSStyleCell(style),"padding-right","5.4pt");
+        CSSPut(CSSStyleCell(style),"padding-top","0pt");
+        CSSPut(CSSStyleCell(style),"padding-bottom","0pt");
+        CSSSheetSetDefaultStyle(converter->styleSheet,style,StyleFamilyTable);
+    }
+}
+
+int WordConverterPut(DFDocument *html, DFStorage *abstractStorage, WordPackage *package, const char *idPrefix, DFError **error)
+{
+    if (package->document == NULL) {
+        DFErrorFormat(error,"document.xml not found");
+        return 0;
+    }
+
+    DFNode *wordDocument = DFChildWithTag(package->document->docNode,WORD_DOCUMENT);
+    if (wordDocument == NULL) {
+        DFErrorFormat(error,"word:document not found");
+        return 0;
+    }
+
+    HTML_normalizeDocument(html);
+    HTML_pushDownInlineProperties(html->docNode);
+
+    WordConverter *converter = WordConverterNew(html,abstractStorage,package,idPrefix);
+
+    // FIXME: Need a more reliable way of telling whether this is a new document or not - it could be that the
+    // document already existed (with styles set up) but did not have any content
+    DFNode *wordBody = DFChildWithTag(wordDocument,WORD_BODY);
+    int creating = ((wordBody == NULL) || (wordBody->first == NULL));
+
+    converter->haveFields = Word_simplifyFields(converter->package);
+    Word_mergeRuns(converter->package);
+
+    assert(converter->package->styles);
+
+    CSSSheetRelease(converter->styleSheet);
+    converter->styleSheet = CSSSheetNew();
+
+    char *cssText = HTMLCopyCSSText(converter->html);
+    CSSSheetUpdateFromCSSText(converter->styleSheet,cssText);
+    free(cssText);
+
+    addMissingDefaultStyles(converter);
+    CSSEnsureReferencedStylesPresent(converter->html,converter->styleSheet);
+    if (creating)
+        CSSSetHTMLDefaults(converter->styleSheet);
+    CSSEnsureUnique(converter->styleSheet,converter->html,creating);
+
+    CSSStyle *pageStyle = CSSSheetLookupElement(converter->styleSheet,"@page",NULL,0,0);
+    CSSStyle *bodyStyle = CSSSheetLookupElement(converter->styleSheet,"body",NULL,1,0);
+    CSSProperties *page = (pageStyle != NULL) ? CSSPropertiesRetain(CSSStyleRule(pageStyle)) : CSSPropertiesNew();
+    CSSProperties *body = (bodyStyle != NULL) ? CSSPropertiesRetain(CSSStyleRule(bodyStyle)) : CSSPropertiesNew();
+
+    if (CSSGet(body,"margin-left") == NULL)
+        CSSPut(body,"margin-left","10%");
+    if (CSSGet(body,"margin-right") == NULL)
+        CSSPut(body,"margin-right","10%");
+    if (CSSGet(body,"margin-top") == NULL)
+        CSSPut(body,"margin-top","10%");
+    if (CSSGet(body,"margin-bottom") == NULL)
+        CSSPut(body,"margin-bottom","10%");
+
+    WordSectionUpdateFromCSSPage(converter->mainSection,page,body);
+
+    WordPutData put;
+    put.conv = converter;
+    put.contentDoc = converter->package->document;
+    put.numIdByHtmlId = DFHashTableNew((DFCopyFunction)xstrdup,free);
+    put.htmlIdByNumId = DFHashTableNew((DFCopyFunction)xstrdup,free);
+
+    // Make sure we update styles.xml from the CSS stylesheet *before* doing any conversion of the content,
+    // since the latter requires a full mapping of CSS selectors to styleIds to be in place.
+    WordUpdateStyles(converter,converter->styleSheet);
+
+    Word_preProcessHTMLDoc(converter,converter->html);
+    buildListMapFromHTML(&put,converter->html->docNode);
+    updateListTypes(&put);
+    WordBookmarks_removeCaptionBookmarks(converter->package->document);
+    WordObjectsCollapseBookmarks(converter->objects);
+    WordObjectsScan(converter->objects);
+    Word_setupBookmarkLinks(&put);
+    WordObjectsAnalyzeBookmarks(converter->objects,converter->styles);
+    WordDocumentLens.put(&put,converter->html->root,wordDocument);
+    WordObjectsExpandBookmarks(converter->objects);
+    WordRemoveNbsps(converter->package->document);
+
+    // Make sure the updateFields flag is set
+    Word_updateSettings(converter->package,converter->haveFields);
+
+    // Remove any abstract numbering definitions that are no longer referenced from concrete
+    // numbering definitions
+    WordNumberingRemoveUnusedAbstractNums(converter->numbering);
+
+    // Remove any relationships and images that have been removed from the HTML file and no longer
+    // have any other references pointing to them
+    WordGarbageCollect(converter->package);
+
+    CSSPropertiesRelease(page);
+    CSSPropertiesRelease(body);
+    DFHashTableRelease(put.numIdByHtmlId);
+    DFHashTableRelease(put.htmlIdByNumId);
+
+    int ok = 1;
+    if (converter->warnings->len > 0) {
+        DFErrorFormat(error,"%s",converter->warnings->data);
+        ok = 0;
+    }
+
+    WordConverterFree(converter);
+    return ok;
+}
+
+void ODFConverterWarning(WordConverter *converter, const char *format, ...)
+{
+    va_list ap;
+    va_start(ap,format);
+    DFBufferVFormat(converter->warnings,format,ap);
+    va_end(ap);
+}
+
+char *WordStyleIdForStyle(CSSStyle *style)
+{
+    const char *selector = style->selector;
+    char *resStyleId = NULL;
+
+    if (!strcmp(selector,"table.Normal_Table"))
+        return xstrdup("TableNormal");
+    if (!strcmp(selector,"table.Table_Grid"))
+        return xstrdup("TableGrid");
+    if (!strcmp(selector,"span.Default_Paragraph_Font"))
+        return xstrdup("DefaultParagraphFont");
+    if (!strcmp(selector,"p.List_Paragraph"))
+        return xstrdup("ListParagraph");
+
+    int headingLevel = CSSSelectorHeadingLevel(selector);
+    if (headingLevel != 0) {
+        char *prefix = DFFormatString("heading_%d",headingLevel);
+        if ((style->className != NULL) && DFStringHasPrefix(style->className,prefix)) {
+            char *rest = DFSubstring(style->className,strlen(prefix),strlen(style->className));
+            char *result = DFFormatString("Heading%d%s",headingLevel,rest);
+            free(rest);
+            free(prefix);
+            return result;
+        }
+        free(prefix);
+    }
+
+    if (!strcmp(selector,"span.Heading1Char"))
+        return xstrdup("Heading1Char");
+    if (!strcmp(selector,"span.Heading2Char"))
+        return xstrdup("Heading2Char");
+    if (!strcmp(selector,"span.Heading3Char"))
+        return xstrdup("Heading3Char");
+    if (!strcmp(selector,"span.Heading4Char"))
+        return xstrdup("Heading4Char");
+    if (!strcmp(selector,"span.Heading5Char"))
+        return xstrdup("Heading5Char");
+    if (!strcmp(selector,"span.Heading6Char"))
+        return xstrdup("Heading6Char");
+    if (!strcmp(selector,"span.Heading7Char"))
+        return xstrdup("Heading7Char");
+    if (!strcmp(selector,"span.Heading8Char"))
+        return xstrdup("Heading8Char");
+    if (!strcmp(selector,"span.Heading9Char"))
+        return xstrdup("Heading9Char");
+
+    char *className = CSSSelectorCopyClassName(selector);
+    switch (CSSSelectorGetTag(selector)) {
+        case HTML_FIGURE: {
+            resStyleId = DFStrDup("Figure");
+            break;
+        }
+        case HTML_CAPTION: {
+            resStyleId = DFStrDup("Caption");
+            break;
+        }
+        case HTML_H1:
+        case HTML_H2:
+        case HTML_H3:
+        case HTML_H4:
+        case HTML_H5:
+        case HTML_H6: {
+            if ((className == NULL) || (strlen(className) == 0)) {
+                int level = CSSSelectorHeadingLevel(selector);
+                if ((level >= 1) && (level <= 6)) {
+                    // FIXME: we shouldn't rely on the specific word "Heading" here - instead using the localised name
+                    // FIXME: not covered by tests
+                    resStyleId = DFFormatString("Heading%d",level);
+                }
+            }
+            else {
+                resStyleId = DFStrDup(className);
+            }
+            break;
+        }
+        case HTML_P:
+            resStyleId = DFStrDup(className);
+            break;
+        case HTML_SPAN:
+            resStyleId = DFStrDup(className);
+            break;
+        case HTML_TABLE:
+            resStyleId = DFStrDup(className);
+            break;
+    }
+    free(className);
+
+    if (resStyleId == NULL) {
+        // Note: selector here may start with . (i.e. applies to all elements)
+        // FIXME: not covered by tests
+        resStyleId = xstrdup(selector);
+    }
+
+    return resStyleId;
+}
+
+StyleFamily WordStyleFamilyForSelector(const char *selector)
+{
+    switch (CSSSelectorGetTag(selector)) {
+        case HTML_FIGURE:
+        case HTML_CAPTION:
+        case HTML_H1:
+        case HTML_H2:
+        case HTML_H3:
+        case HTML_H4:
+        case HTML_H5:
+        case HTML_H6:
+            return StyleFamilyParagraph;
+        case HTML_P: {
+            char *className = CSSSelectorCopyClassName(selector);
+            StyleFamily family = (className != NULL) ? StyleFamilyParagraph : StyleFamilySpecial;
+            free(className);
+            return family;
+        }
+        case HTML_SPAN:
+            return StyleFamilyCharacter;
+        case HTML_TABLE:
+            return StyleFamilyTable;
+        default:
+            return StyleFamilySpecial;
+    }
+}
+
+
+// 1i: common code??g
+void childrenToArray(DFNode *node, DFNode **children)
+{
+    bzero(children,PREDEFINED_TAG_COUNT*sizeof(DFNode *));
+    for (DFNode *child = node->first; child != NULL; child = child->next) {
+        if ((child->tag >= MIN_ELEMENT_TAG) && (child->tag < PREDEFINED_TAG_COUNT))
+            children[child->tag] = child;
+    }
+}
+
+void replaceChildrenFromArray(DFNode *node, DFNode **children, Tag *tags)
+{
+    while (node->first != NULL)
+        DFRemoveNode(node->first);
+
+    for (int i = 0; tags[i] != 0; i++) {
+        if (children[tags[i]])
+            DFAppendChild(node,children[tags[i]]);
+    }
+}
+*/

http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/c4ea2ed9/DocFormats/filters/ooxml/src/odf/ODFConverter.h
----------------------------------------------------------------------
diff --git a/DocFormats/filters/ooxml/src/odf/ODFConverter.h b/DocFormats/filters/ooxml/src/odf/ODFConverter.h
new file mode 100644
index 0000000..bbe47b5
--- /dev/null
+++ b/DocFormats/filters/ooxml/src/odf/ODFConverter.h
@@ -0,0 +1,117 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#ifndef DocFormats_ODFConverter_h
+#define DocFormats_ODFConverter_h
+
+#include "ODFPackage.h"
+#include "DFXMLNames.h"
+#include "DFBDT.h"
+#include "DFDOM.h"
+#include "DFClassNames.h"
+#include <DocFormats/DFXMLForward.h>
+#include "CSSSelector.h"
+#include "CSSSheet.h"
+#include "OOXMLTypedefs.h"
+#include <DocFormats/DFStorage.h>
+/*
+#define EMUS_PER_POINT 12700
+
+#define A4_WIDTH_TWIPS 11900
+#define A4_HEIGHT_TWIPS 16840
+#define LETTER_WIDTH_TWIPS 12240
+#define LETTER_HEIGHT_TWIPS 15840
+
+#define WORDREL_SETTINGS "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings"
+#define WORDREL_WEBSETTINGS "http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings"
+#define WORDREL_FONTTABLE "http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable"
+#define WORDREL_THEME "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme"
+#define WORDREL_NUMBERING "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering"
+#define WORDREL_STYLES "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles"
+#define WORDREL_CORE_PROPERTIES "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties"
+#define WORDREL_EXTENDED_PROPERTIES "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties"
+#define WORDREL_OFFICE_DOCUMENT "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"
+#define WORDREL_THUMBNAIL "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail"
+#define WORDREL_HYPERLINK "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"
+#define WORDREL_IMAGE "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image"
+#define WORDREL_FOOTNOTES "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes"
+#define WORDREL_ENDNOTES "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes"
+
+#define WORDTYPE_SETTINGS "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"
+#define WORDTYPE_WEBSETTINGS "application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml"
+#define WORDTYPE_FONTTABLE "application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"
+#define WORDTYPE_THEME "application/vnd.openxmlformats-officedocument.theme+xml"
+#define WORDTYPE_NUMBERING "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"
+#define WORDTYPE_STYLES "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"
+#define WORDTYPE_CORE_PROPERTIES "application/vnd.openxmlformats-package.core-properties+xml"
+#define WORDTYPE_EXTENDED_PROPERTIES "application/vnd.openxmlformats-officedocument.extended-properties+xml"
+#define WORDTYPE_OFFICE_DOCUMENT "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"
+#define WORDTYPE_FOOTNOTES "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml"
+#define WORDTYPE_ENDNOTES "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml"
+
+int Word_isFigureParagraph(DFNode *p);
+int Word_isEquationParagraph(DFNode *p);
+*/
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//                                                                                                //
+//                                          ODFConverter                                          //
+//                                                                                                //
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct ODFGetData {
+    ODFConverter *conv;
+};
+
+struct ODFPutData {
+    ODFConverter *conv;
+    DFDocument *contentDoc;
+    DFHashTable *numIdByHtmlId;
+    DFHashTable *htmlIdByNumId;
+};
+
+struct ODFConverter {
+    DFDocument *html;
+    DFStorage *abstractStorage;
+    char *idPrefix;
+    ODFPackage *package;
+    struct ODFSheet *styles;
+    struct ODFNumbering *numbering;
+    struct ODFTheme *theme;
+    struct ODFSection *mainSection;
+    struct ODFObjects *objects;
+    struct ODFNoteGroup *footnotes;
+    struct ODFNoteGroup *endnotes;
+    DFHashTable *supportedContentTypes;
+    DFBuffer *warnings;
+    int haveFields;
+    CSSSheet *styleSheet;
+};
+
+int ODFConverterGet(DFDocument *html, DFStorage *abstractStorage, ODFPackage *package, const char *idPrefix, DFError **error);
+int ODFConverterPut(DFDocument *html, DFStorage *abstractStorage, ODFPackage *package, const char *idPrefix, DFError **error);
+void ODFConverterWarning(ODFConverter *converter, const char *format, ...) ATTRIBUTE_FORMAT(printf,2,3);
+
+char *ODFStyleIdForStyle(CSSStyle *style);
+StyleFamily ODFStyleFamilyForSelector(const char *selector);
+
+DFNode *ODFConverterCreateAbstract(ODFGetData *get, Tag tag, DFNode *concrete);
+DFNode *ODFConverterGetConcrete(ODFPutData *put, DFNode *abstract);
+
+void childrenToArray(DFNode *node, DFNode **children);
+void replaceChildrenFromArray(DFNode *node, DFNode **children, Tag *tags);
+
+#endif


Mime
View raw message