corinthia-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Peter Kelly <pmke...@apache.org>
Subject Re: incubator-corinthia git commit: Copy parts of src/word/lenses to src/odf/lenses/.
Date Fri, 24 Apr 2015 15:59:13 GMT
I’d like to recommend a different strategy: Rather than copying across code from the Word
filter, I think it would be easier to organically “grow” the code based on implementing
support for the ODF types. I noticed that some of the code copied across is data structures
and algorithms that are very specific to OOXML and don’t have any corresponding meaning
in ODF - fields for example work completely differently.

The same goes for ODFCoverterGet; the set of steps you’d use pre- and post- main translation
would be very different to those of word. Things like collapsing bookmarks, fixing list representation
etc. similarly have no analogous implementation for ODF.

Here’s what I would recommend:

- Start by doing just an ODF to HTML translation, without regard to going the other way.
- Do a traversal of the DOM tree of the content.xml file from the ODF package, producing a
HTML document as you go. You could do this in either one recursive function, or several different
functions (one for each type, e.g. paragraph, table, list etc).
- This will give you a handle on the basic conversion process in action, and you can produce
a number of test cases as you go. When you’ve got these I can help you get them into a similar
format as the automated tests for Word; but we’ll cross that bridge when we come to it.
- After this, we can look at adding node identifiers to the generated ODF elements, and then
implementing the put operatino

—
Dr Peter M. Kelly
pmkelly@apache.org

PGP key: http://www.kellypmk.net/pgp-key <http://www.kellypmk.net/pgp-key>
(fingerprint 5435 6718 59F0 DD1F BFA0 5E46 2523 BAA1 44AE 2966)

> On 24 Apr 2015, at 8:31 pm, gbg@apache.org wrote:
> 
> Repository: incubator-corinthia
> Updated Branches:
>  refs/heads/master ff322cb4f -> 83720d9dd
> 
> 
> Copy parts of src/word/lenses to src/odf/lenses/.
> 
> * DocFormats/filters/odf/src/text/ODFText.c
> 
>  (ODFTextGet): Uncomment section.  Function now 'works'.
> 
> * DocFormats/filters/ooxml/CMakeLists.txt
> 
>  (set): Add new group: GroupOOXMLODFLenses.
>         Add files: src/odf/lenses/ODFField.*
> 
>  (add_library): Add groups GroupOOXMODF and GroupOOXMLODFLenses.
> 
> * DocFormats/filters/ooxml/src/odf/ODFConverter.c
> 
>  (#include): Add temporary stdio.h for easy debugging.
> 
>  (WordConverterGetConcrete): Change Error message.  Add temporary
>    magic number in lieu of OFFICE_DOCUMENT not seeming to be the
>    right choice.  Move commmenting out below ODF_simplifyFields()
>    call.
> 
> * DocFormats/filters/ooxml/src/odf/lenses/ODFField.h
> 
>  (): New file.  String replaced copy of  /word/lenses/
> 
> * DocFormats/filters/ooxml/src/odf/lenses/ODFField.c
> 
>  (): New file.  String replaced copy of  /word/lenses/
> 
> 
> Project: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/repo
> Commit: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/commit/83720d9d
> Tree: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/tree/83720d9d
> Diff: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/diff/83720d9d
> 
> Branch: refs/heads/master
> Commit: 83720d9ddad4d1021e3cf0b416ebd7a761771cae
> Parents: ff322cb
> Author: Gabriela Gibson <gbg@apache.org>
> Authored: Fri Apr 24 14:31:43 2015 +0100
> Committer: Gabriela Gibson <gbg@apache.org>
> Committed: Fri Apr 24 14:31:43 2015 +0100
> 
> ----------------------------------------------------------------------
> DocFormats/filters/odf/src/text/ODFText.c       |   4 +-
> DocFormats/filters/ooxml/CMakeLists.txt         |  10 +-
> DocFormats/filters/ooxml/src/odf/ODFConverter.c |  13 +-
> .../filters/ooxml/src/odf/lenses/ODFField.c     | 494 +++++++++++++++++++
> .../filters/ooxml/src/odf/lenses/ODFField.h     |  27 +
> 5 files changed, 540 insertions(+), 8 deletions(-)
> ----------------------------------------------------------------------
> 
> 
> http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/83720d9d/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 683e2d6..417aea9 100644
> --- a/DocFormats/filters/odf/src/text/ODFText.c
> +++ b/DocFormats/filters/odf/src/text/ODFText.c
> @@ -41,7 +41,7 @@ DFDocument *ODFTextGet(DFStorage *concreteStorage, DFStorage *abstractStorage,
c
>     ok = 1;
> 
> end:
> -    /*
> +
>     ODFPackageRelease(odfPackage);
>     if (ok) {
>         return htmlDoc;
> @@ -50,7 +50,7 @@ end:
>         DFDocumentRelease(htmlDoc);
>         return NULL;
>     }
> -    */
> +
>     return NULL;
> }
> 
> 
> http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/83720d9d/DocFormats/filters/ooxml/CMakeLists.txt
> ----------------------------------------------------------------------
> diff --git a/DocFormats/filters/ooxml/CMakeLists.txt b/DocFormats/filters/ooxml/CMakeLists.txt
> index 4696309..3ba0b01 100644
> --- a/DocFormats/filters/ooxml/CMakeLists.txt
> +++ b/DocFormats/filters/ooxml/CMakeLists.txt
> @@ -29,6 +29,13 @@ set(GroupOOXMLODF
>     src/odf/ODFConverter.c
>     src/odf/ODFConverter.h)
> 
> +###
> +## group ooxml odf lenses objects
> +###
> +set(GroupOOXMLODFLenses
> +    src/odf/lenses/ODFField.c
> +    src/odf/lenses/ODFField.h)
> +    
> 
> ###
> ## group ooxml word objects
> @@ -160,7 +167,8 @@ add_library(ooxml OBJECT
>     ${GroupOOXMLWordFormatting}
>     ${GroupOOXMLWordLenses}
>     ${GroupOOXMLWordTests}
> -    ${GroupOOXMLODF})
> +    ${GroupOOXMLODF}
> +    ${GroupOOXMLODFLenses})
> 
> source_group(src\\common           FILES ${GroupOOXMLCommon})
> source_group(src\\word             FILES ${GroupOOXMLWord})
> 
> http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/83720d9d/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
> index c7d79e8..3a21567 100644
> --- a/DocFormats/filters/ooxml/src/odf/ODFConverter.c
> +++ b/DocFormats/filters/ooxml/src/odf/ODFConverter.c
> @@ -54,6 +54,8 @@
> #include <stdlib.h>
> #include <string.h>
> 
> +// 1i: debugging include --- remove
> +#include <stdio.h>
> /*
> static int isWhitespaceRun(DFNode *run)
> {
> @@ -688,20 +690,21 @@ DFNode *WordConverterGetConcrete(WordPutData *put, DFNode *abstract)
> 
> 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");
> +        DFErrorFormat(error,"content.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);
> +    // 1i: this line needs work on the xml tags.
> +    printf("OFFICE_DOCUMENT is %d\n", OFFICE_DOCUMENT);
> +    DFNode *odfDocument = DFChildWithTag(package->contentDoc->docNode,1469 /*
magic number for what I found in gdb */);
>     if (odfDocument == NULL) {
>         DFErrorFormat(error,"odf:document not found");
>         return 0;
>     }
> +
> +    int haveFields = ODF_simplifyFields(package);
>     /*
> -    int haveFields = Word_simplifyFields(package);
>     Word_mergeRuns(package);
> 
>     WordConverter *converter = WordConverterNew(html,abstractStorage,package,idPrefix);
> 
> http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/83720d9d/DocFormats/filters/ooxml/src/odf/lenses/ODFField.c
> ----------------------------------------------------------------------
> diff --git a/DocFormats/filters/ooxml/src/odf/lenses/ODFField.c b/DocFormats/filters/ooxml/src/odf/lenses/ODFField.c
> new file mode 100644
> index 0000000..e7abf45
> --- /dev/null
> +++ b/DocFormats/filters/ooxml/src/odf/lenses/ODFField.c
> @@ -0,0 +1,494 @@
> +// 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 "ODFField.h"
> +/*
> +#include "ODFLenses.h"
> +#include "ODFBookmark.h"
> +#include "ODFObjects.h"
> +#include "ODFPackage.h"
> +#include "ODFCaption.h"
> +*/
> +
> +#include "DFDOM.h"
> +#include "DFXML.h"
> +#include "DFString.h"
> +#include "DFArray.h"
> +#include "DFCommon.h"
> +#include <assert.h>
> +#include <ctype.h>
> +#include <stdlib.h>
> +#include <string.h>
> +
> +/*
> +static void ODFFieldPut(ODFPutData *put, DFNode *abstract, DFNode *concrete);
> +
> +const char **ODF_parseField(const char *str)
> +{
> +    size_t len = strlen(str);
> +    DFArray *components = DFArrayNew((DFCopyFunction)xstrdup,free);
> +
> +    size_t start = 0;
> +    int inString = 0;
> +    for (size_t pos = 0; pos <= len; pos++) {
> +        if (inString) {
> +            if ((pos == len) || (str[pos] == '"')) {
> +                char *comp = DFSubstring(str,start,pos);
> +                DFArrayAppend(components,(char *)comp);
> +                free(comp);
> +                start = pos+1;
> +                inString = 0;
> +            }
> +        }
> +        else {
> +            if ((pos == len) || isspace(str[pos])) {
> +                if (pos > start) {
> +                    char *comp = DFSubstring(str,start,pos);
> +                    DFArrayAppend(components,(char *)comp);
> +                    free(comp);
> +                }
> +                start = pos+1;
> +            }
> +            else if (str[pos] == '"') {
> +                inString = 1;
> +                start = pos+1;
> +            }
> +        }
> +    }
> +
> +    const char **result = DFStringArrayFlatten(components);
> +    DFArrayRelease(components);
> +    return result;
> +}
> +
> +////////////////////////////////////////////////////////////////////////////////////////////////////
> +//                                                                                 
              //
> +//                                       DOM helper methods                        
              //
> +//                                                                                 
              //
> +////////////////////////////////////////////////////////////////////////////////////////////////////
> +
> +typedef struct {
> +    DFNode *commonAncestor;
> +    DFNode *beginAncestor;
> +    DFNode *endAncestor;
> +} CommonAncestorInfo;
> +
> +static CommonAncestorInfo findCommonAncestor(DFNode *beginNode, DFNode *endNode)
> +{
> +    CommonAncestorInfo info = { NULL, NULL, NULL };
> +    for (DFNode *beginA = beginNode; beginA != NULL; beginA = beginA->parent) {
> +        for (DFNode *endA = endNode; endA != NULL; endA = endA->parent) {
> +            if (beginA->parent == endA->parent) {
> +                info.commonAncestor = beginA->parent;
> +                info.beginAncestor = beginA;
> +                info.endAncestor = endA;
> +                return info;
> +            }
> +        }
> +    }
> +    return info;
> +}
> +
> +static void removeNodes(DFNode *beginNode, DFNode *endNode)
> +{
> +    CommonAncestorInfo common = findCommonAncestor(beginNode,endNode);
> +    assert(common.commonAncestor != NULL);
> +    assert(common.beginAncestor != NULL);
> +    assert(common.endAncestor != NULL);
> +
> +    DFNode *begin = beginNode;
> +    while (begin != common.beginAncestor) {
> +        DFNode *parent = begin->parent;
> +        if (begin->next != NULL)
> +            DFRemoveNode(begin->next);
> +        else
> +            begin = parent;
> +    }
> +
> +    DFNode *end = endNode;
> +    while (end != common.endAncestor) {
> +        DFNode *parent = end->parent;
> +        if (end->prev != NULL)
> +            DFRemoveNode(end->prev);
> +        else
> +            end = parent;
> +    }
> +
> +    if (common.beginAncestor != common.endAncestor) {
> +        while (common.beginAncestor->next != common.endAncestor)
> +            DFRemoveNode(common.beginAncestor->next);
> +    }
> +
> +    while ((beginNode != NULL) && (beginNode->first == NULL) && (beginNode->tag
!= WORD_DOCUMENT)) {
> +        DFNode *parent = beginNode->parent;
> +        DFRemoveNode(beginNode);
> +        beginNode = parent;
> +    }
> +
> +    while ((endNode != NULL) && (endNode->first == NULL) && (endNode->tag
!= WORD_DOCUMENT)) {
> +        DFNode *parent = endNode->parent;
> +        DFRemoveNode(endNode);
> +        endNode = parent;
> +    }
> +}
> +*/
> +////////////////////////////////////////////////////////////////////////////////////////////////////
> +//                                                                                 
              //
> +//                                       ODFSimplification                         
             //
> +//                                                                                 
              //
> +////////////////////////////////////////////////////////////////////////////////////////////////////
> +
> +typedef struct ODFSimplification {
> +    DFBuffer *instrText;
> +    DFNode *beginNode;
> +    DFNode *endNode;
> +    int haveFields;
> +    int inSeparate;
> +    int depth;
> +} ODFSimplification;
> +
> +static void replaceField(ODFSimplification *simp)
> +{
> +    assert(simp->instrText != NULL);
> +    assert(simp->beginNode != NULL);
> +    assert(simp->endNode != NULL);
> +
> +    if ((simp->beginNode->parent->tag == WORD_R) && (simp->endNode->parent->tag
== WORD_R)) {
> +        DFNode *beginRun = simp->beginNode->parent;
> +
> +        DFNode *simple = DFCreateElement(simp->beginNode->doc,WORD_FLDSIMPLE);
> +        DFSetAttribute(simple,WORD_INSTR,simp->instrText->data);
> +        DFInsertBefore(beginRun->parent,simple,beginRun);
> +        // 1i: plug in later
> +        //removeNodes(simp->beginNode,simp->endNode);
> +    }
> +
> +    DFBufferRelease(simp->instrText);
> +    simp->instrText = NULL;
> +    simp->beginNode = NULL;
> +    simp->endNode = NULL;
> +
> +    simp->haveFields = 1;
> +}
> +
> +static void simplifyRecursive(ODFSimplification *simp, DFNode *node)
> +{
> +    switch (node->tag) {
> +        case WORD_FLDCHAR: {
> +            const char *type = DFGetAttribute(node,WORD_FLDCHARTYPE);
> +            if (DFStringEquals(type,"begin")) {
> +                if (simp->depth == 0) {
> +                    DFBufferRelease(simp->instrText);
> +                    simp->instrText = DFBufferNew();
> +                    simp->beginNode = node;
> +                    simp->endNode = NULL;
> +                    simp->inSeparate = 0;
> +                }
> +                simp->depth++;
> +            }
> +            else if (DFStringEquals(type,"end") && (simp->depth > 0))
{
> +                simp->depth--;
> +                if (simp->depth == 0) {
> +                    simp->endNode = node;
> +                    replaceField(simp);
> +                }
> +            }
> +            else if (DFStringEquals(type,"separate")) {
> +                if (simp->depth == 1)
> +                    simp->inSeparate = 1;
> +            }
> +            break;
> +        }
> +        case WORD_INSTRTEXT: {
> +            if ((simp->depth == 1) && !simp->inSeparate) {
> +                char *value = DFNodeTextToString(node);
> +                DFBufferFormat(simp->instrText,"%s",value);
> +                free(value);
> +            }
> +            break;
> +        }
> +    }
> +
> +    DFNode *next;
> +    for (DFNode *child = node->first; child != NULL; child = next) {
> +        next = child->next;
> +        simplifyRecursive(simp,child);
> +    }
> +}
> +
> +int ODF_simplifyFields(ODFPackage *package)
> +{
> +    ODFSimplification simp;
> +    bzero(&simp,sizeof(ODFSimplification));
> +    simplifyRecursive(&simp,package->contentDoc->docNode);
> +    DFBufferRelease(simp.instrText);
> +    return simp.haveFields;
> +}
> +
> +////////////////////////////////////////////////////////////////////////////////////////////////////
> +//                                                                                 
              //
> +//                                          ODFFieldLens                           
             //
> +//                                                                                 
              //
> +////////////////////////////////////////////////////////////////////////////////////////////////////
> +/*
> +typedef enum {
> +    ODFRefUnknown,
> +    ODFRefNum,
> +    ODFRefText,
> +    ODFRefDirection,
> +    ODFRefCaptionText,
> +    ODFRefLabelNum,
> +} ODFRefType;
> +
> +static const char *ODFRefTypeClassName(ODFRefType refType)
> +{
> +    switch (refType) {
> +        case ODFRefText:
> +            return DFRefTextClass;
> +        case ODFRefDirection:
> +            return DFRefDirectionClass;
> +        case ODFRefCaptionText:
> +            return DFRefCaptionTextClass;
> +        case ODFRefLabelNum:
> +            return DFRefLabelNumClass;
> +        case ODFRefNum:
> +        default:
> +            return DFRefNumClass;
> +    }
> +}
> +
> +static ODFRefType ODFRefTypeGet(const char **args, ODFBookmark *bookmark)
> +{
> +    size_t argCount = DFStringArrayCount(args);
> +    ODFRefType type = ODFRefText;
> +
> +    for (size_t argno = 2; argno < argCount; argno++) {
> +        const char *arg = args[argno];
> +        if (!strcmp(arg,"\\r"))
> +            type = ODFRefNum; // Numbered reference (normal)
> +        else if (!strcmp(arg,"\\n"))
> +            type = ODFRefNum; // Numbered reference (no context)
> +        else if (!strcmp(arg,"\\w"))
> +            type = ODFRefNum; // Numbered reference (full context)
> +        else if (!strcmp(arg,"\\p"))
> +            type = ODFRefDirection;
> +    }
> +
> +    if ((bookmark->type == ODFBookmarkTable) ||
> +        (bookmark->type == ODFBookmarkFigure) ||
> +        (bookmark->type == ODFBookmarkEquation)) {
> +        if (type == ODFRefText) {
> +            DFNode *p = ODFFindContainingParagraph(bookmark->element);
> +            if (p != NULL) {
> +                CaptionParts parts = ODFBookmarkGetCaptionParts(bookmark);
> +
> +                if (parts.beforeNum && !parts.num && !parts.afterNum)
> +                    type = ODFRefCaptionText;
> +                else if (parts.beforeNum && parts.num && !parts.afterNum)
> +                    type = ODFRefLabelNum;
> +            }
> +        }
> +    }
> +
> +    return type;
> +}
> +
> +static DFNode *ODFFieldGet(ODFGetData *get, DFNode *concrete)
> +{
> +    if (concrete->tag != WORD_FLDSIMPLE)
> +        return NULL;;
> +
> +    const char *instr = DFGetAttribute(concrete,WORD_INSTR);
> +    if (instr != NULL) {
> +        const char **args = ODF_parseField(instr);
> +        size_t argCount = DFStringArrayCount(args);
> +
> +        if ((argCount >= 2) && !strcmp(args[0],"REF")) {
> +            ODFBookmark *bookmark = ODFObjectsBookmarkWithName(get->conv->objects,args[1]);
> +            if ((bookmark != NULL) && (bookmark->target != NULL)) {
> +
> +                ODFRefType type = ODFRefTypeGet(args,bookmark);
> +
> +                DFNode *a = ODFConverterCreateAbstract(get,HTML_A,concrete);
> +                DFFormatAttribute(a,HTML_HREF,"#%s%u",get->conv->idPrefix,bookmark->target->seqNo);
> +                DFSetAttribute(a,HTML_CLASS,ODFRefTypeClassName(type));
> +
> +                free(args);
> +                return a;
> +            }
> +        }
> +        else if ((argCount >= 1) && !strcmp(args[0],"TOC")) {
> +
> +            if ((argCount >= 2) && !strcmp(args[1],"\\o")) {
> +                DFNode *nav = ODFConverterCreateAbstract(get,HTML_NAV,concrete);
> +                DFSetAttribute(nav,HTML_CLASS,DFTableOfContentsClass);
> +                free(args);
> +                return nav;
> +            }
> +            else if ((argCount >= 3) && !strcmp(args[1],"\\c")) {
> +                // FIXME: The names "Figure" and "Table" here will be different if the
document
> +                // was created in a language other than English. We need to look through
the
> +                // document to figure out which counter names are used in captions adjacent
to
> +                // figures and tables to know what the counter names used in the document
> +                // actually are.
> +
> +                // Another option might be just to collect a static list of names used
in all the
> +                // major languages and base the detection on that. These would need
to be checked
> +                // with multiple versions of word, as the names used could in theory
change
> +                // between releases.
> +
> +                // We should keep track of a set of "document parameters", which record
the names
> +                // used for figure and table counters, as well as the prefixes used
on numbered
> +                // figures and tables. The latter would correspond to the content property
of the
> +                // caption::before and figcaption::before CSS rules.
> +
> +                if (!strcmp(args[2],"Figure")) {
> +                    DFNode *nav = ODFConverterCreateAbstract(get,HTML_NAV,concrete);
> +                    DFSetAttribute(nav,HTML_CLASS,DFListOfFiguresClass);
> +                    free(args);
> +                    return nav;
> +                }
> +                else if (!strcmp(args[2],"Table")) {
> +                    DFNode *nav = ODFConverterCreateAbstract(get,HTML_NAV,concrete);
> +                    DFSetAttribute(nav,HTML_CLASS,DFListOfTablesClass);
> +                    free(args);
> +                    return nav;
> +                }
> +            }
> +        }
> +
> +        DFNode *span = ODFConverterCreateAbstract(get,HTML_SPAN,concrete);
> +        DFSetAttribute(span,HTML_CLASS,DFFieldClass);
> +        DFNode *text = DFCreateTextNode(get->conv->html,instr);
> +        DFAppendChild(span,text);
> +        free(args);
> +        return span;
> +    }
> +    return NULL;
> +}
> +
> +static int ODFFieldIsVisible(ODFPutData *put, DFNode *concrete)
> +{
> +    return 1;
> +}
> +
> +static DFNode *ODFFieldCreate(ODFPutData *put, DFNode *abstract)
> +{
> +    DFNode *concrete = DFCreateElement(put->contentDoc,WORD_FLDSIMPLE);
> +    // fldSimple elements are required to have an instr attribute (even if it's empty),
so set
> +    // it here in case update doesn't change it for some reason
> +    DFSetAttribute(concrete,WORD_INSTR,"");
> +    ODFFieldPut(put,abstract,concrete);
> +    put->conv->haveFields = 1;
> +    return concrete;
> +}
> +
> +static const char *bookmarkNameForHtmlId(ODFConverter *converter, const char *htmlId,
const char *refClass)
> +{
> +    DFNode *htmlElem = DFElementForIdAttr(converter->html,htmlId);
> +    if (htmlElem == NULL)
> +        return NULL;
> +    switch (htmlElem->tag) {
> +        case HTML_H1:
> +        case HTML_H2:
> +        case HTML_H3:
> +        case HTML_H4:
> +        case HTML_H5:
> +        case HTML_H6: {
> +            DFNode *labelSpan = htmlElem->first;
> +            if ((labelSpan == NULL) || (labelSpan->tag != HTML_SPAN))
> +                return NULL;;
> +            const char *labelClass = DFGetAttribute(labelSpan,HTML_CLASS);
> +            if (!DFStringEquals(labelClass,DFBookmarkClass))
> +                return NULL;
> +            return DFGetAttribute(labelSpan,WORD_NAME);
> +        }
> +        case HTML_FIGURE:
> +        case HTML_TABLE: {
> +            ODFCaption *caption = ODFObjectsCaptionForTarget(converter->objects,htmlElem);
> +            if (caption == NULL)
> +                return NULL;
> +            if (DFStringEquals(refClass,DFRefTextClass) && (caption->textBookmark
!= NULL))
> +                return caption->textBookmark->bookmarkName;
> +            else if (DFStringEquals(refClass,DFRefLabelNumClass) && (caption->labelNumBookmark
!= NULL))
> +                return caption->labelNumBookmark->bookmarkName;
> +            else if (DFStringEquals(refClass,DFRefCaptionTextClass) && (caption->captionTextBookmark
!= NULL))
> +                return caption->captionTextBookmark->bookmarkName;
> +            else if (caption->textBookmark != NULL)
> +                return caption->textBookmark->bookmarkName; // default is entire
caption
> +        }
> +        default:
> +            return NULL;
> +    }
> +}
> +
> +static void ODFFieldPut(ODFPutData *put, DFNode *abstract, DFNode *concrete)
> +{
> +    switch (abstract->tag) {
> +        case HTML_SPAN: {
> +            const char *className = DFGetAttribute(abstract,HTML_CLASS);
> +            if (!DFStringEquals(className,DFFieldClass))
> +                return;
> +            char *text = DFNodeTextToString(abstract);
> +            DFSetAttribute(concrete,WORD_INSTR,text);
> +            free(text);
> +            break;
> +        }
> +        case HTML_A: {
> +            const char *href = DFGetAttribute(abstract,HTML_HREF);
> +            if ((href == NULL) || (href[0] != '#'))
> +                return;;
> +
> +            const char *targetId = &href[1];
> +            const char *className = DFGetAttribute(abstract,HTML_CLASS);
> +            if (className == NULL)
> +                className = "";;
> +            const char *bookmarkName = bookmarkNameForHtmlId(put->conv,targetId,className);
> +            if (bookmarkName == NULL)
> +                return;;
> +
> +            DFNode *htmlElem = DFElementForIdAttr(put->conv->html,targetId);
> +            if ((htmlElem != NULL) && ((htmlElem->tag == HTML_TABLE) || (htmlElem->tag
== HTML_FIGURE))) {
> +                if (!DFStringEquals(className,DFRefTextClass) &&
> +                    !DFStringEquals(className,DFRefLabelNumClass) &&
> +                    !DFStringEquals(className,DFRefCaptionTextClass))
> +                    className = DFRefTextClass;
> +            }
> +
> +            if (DFStringEquals(className,DFRefTextClass) ||
> +                DFStringEquals(className,DFRefLabelNumClass) ||
> +                DFStringEquals(className,DFRefCaptionTextClass))
> +                DFFormatAttribute(concrete,WORD_INSTR," REF %s \\h ",bookmarkName);
> +            else if (DFStringEquals(className,DFRefDirectionClass))
> +                DFFormatAttribute(concrete,WORD_INSTR," REF %s \\p \\h ",bookmarkName);
> +            else
> +                DFFormatAttribute(concrete,WORD_INSTR," REF %s \\r \\h ",bookmarkName);
> +            break;
> +        }
> +    }
> +}
> +
> +ODFLens ODFFieldLens = {
> +    .isVisible = ODFFieldIsVisible,
> +    .get = ODFFieldGet,
> +    .put = ODFFieldPut,
> +    .create = ODFFieldCreate,
> +    .remove = NULL, // LENS FIXME
> +};
> +
> +*/
> 
> http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/83720d9d/DocFormats/filters/ooxml/src/odf/lenses/ODFField.h
> ----------------------------------------------------------------------
> diff --git a/DocFormats/filters/ooxml/src/odf/lenses/ODFField.h b/DocFormats/filters/ooxml/src/odf/lenses/ODFField.h
> new file mode 100644
> index 0000000..99e4252
> --- /dev/null
> +++ b/DocFormats/filters/ooxml/src/odf/lenses/ODFField.h
> @@ -0,0 +1,27 @@
> +// 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_ODFField_h
> +#define DocFormats_ODFField_h
> +
> +#include "ODFPackage.h"
> +
> +const char **ODF_parseField(const char *cstr);
> +
> +int ODF_simplifyFields(ODFPackage *package);
> +
> +#endif
> 


Mime
  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message