| // 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 "WordConverter.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 WordConverter *WordConverterNew(DFDocument *html, DFStorage *abstractStorage, WordPackage *package, const char *idPrefix) |
| { |
| WordConverter *converter = (WordConverter *)xcalloc(1,sizeof(WordConverter)); |
| 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 WordConverterFree(WordConverter *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 WordConverterGet(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; |
| } |
| |
| 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; |
| } |
| |
| WordConverterFree(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 WordConverterWarning(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; |
| } |
| } |
| |
| 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]]); |
| } |
| } |
