Return-Path: X-Original-To: apmail-corinthia-commits-archive@minotaur.apache.org Delivered-To: apmail-corinthia-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id ABC01175AB for ; Fri, 24 Apr 2015 13:33:13 +0000 (UTC) Received: (qmail 66843 invoked by uid 500); 24 Apr 2015 13:33:12 -0000 Delivered-To: apmail-corinthia-commits-archive@corinthia.apache.org Received: (qmail 66792 invoked by uid 500); 24 Apr 2015 13:33:12 -0000 Mailing-List: contact commits-help@corinthia.incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@corinthia.incubator.apache.org Delivered-To: mailing list commits@corinthia.incubator.apache.org Received: (qmail 66765 invoked by uid 99); 24 Apr 2015 13:33:12 -0000 Received: from athena.apache.org (HELO athena.apache.org) (140.211.11.136) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 24 Apr 2015 13:33:12 +0000 X-ASF-Spam-Status: No, hits=-0.0 required=5.0 tests=SPF_PASS X-Spam-Check-By: apache.org Received-SPF: pass (athena.apache.org: local policy) Received: from [54.164.171.186] (HELO mx1-us-east.apache.org) (54.164.171.186) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 24 Apr 2015 13:33:05 +0000 Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by mx1-us-east.apache.org (ASF Mail Server at mx1-us-east.apache.org) with SMTP id 613FB43E46 for ; Fri, 24 Apr 2015 13:32:44 +0000 (UTC) Received: (qmail 57569 invoked by uid 99); 24 Apr 2015 13:31:29 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 24 Apr 2015 13:31:29 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 03FAFE099D; Fri, 24 Apr 2015 13:31:29 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: gbg@apache.org To: commits@corinthia.incubator.apache.org Message-Id: <5c2d0ab2462b49aabfd4b0bd0c7b9b91@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: incubator-corinthia git commit: Copy parts of src/word/lenses to src/odf/lenses/. Date: Fri, 24 Apr 2015 13:31:29 +0000 (UTC) X-Virus-Checked: Checked by ClamAV on apache.org 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 Authored: Fri Apr 24 14:31:43 2015 +0100 Committer: Gabriela Gibson 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 #include +// 1i: debugging include --- remove +#include /* 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 +#include +#include +#include + +/* +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