| // 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 "WordBookmark.h" |
| #include "WordLenses.h" |
| #include "DFDOM.h" |
| #include "WordPackage.h" |
| #include "WordField.h" |
| #include "WordObjects.h" |
| #include "WordCaption.h" |
| #include "WordSheet.h" |
| #include "DFHTML.h" |
| #include "DFString.h" |
| #include "DFCommon.h" |
| #include "DFPlatform.h" |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| static void findTargetAndType(WordBookmark *bookmark, WordSheet *sheet); |
| void findLabel(WordBookmark *bookmark); |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // // |
| // WordBookmark // |
| // // |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| const char *WordBookmarkTypeString(WordBookmarkType type) |
| { |
| switch (type) { |
| case WordBookmarkCursor: |
| return "Cursor"; |
| case WordBookmarkHeading: |
| return "Heading"; |
| case WordBookmarkTable: |
| return "Table"; |
| case WordBookmarkFigure: |
| return "Figure"; |
| case WordBookmarkEquation: |
| return "Equation"; |
| default: |
| return "Unknown"; |
| } |
| } |
| |
| int WordBookmarkTypeHasLabel(WordBookmarkType type) |
| { |
| switch (type) { |
| case WordBookmarkHeading: |
| case WordBookmarkTable: |
| case WordBookmarkFigure: |
| return 1; |
| default: |
| return 0; |
| } |
| } |
| |
| WordBookmark *WordBookmarkNew(const char *bookmarkId1, const char *bookmarkName1) |
| { |
| WordBookmark *bookmark = (WordBookmark *)xcalloc(1,sizeof(WordBookmark)); |
| bookmark->retainCount = 1; |
| bookmark->bookmarkId = (bookmarkId1 != NULL) ? xstrdup(bookmarkId1) : NULL; |
| bookmark->bookmarkName = (bookmarkName1 != NULL) ? xstrdup(bookmarkName1) : NULL; |
| bookmark->type = WordBookmarkUnknown; |
| return bookmark; |
| } |
| |
| WordBookmark *WordBookmarkRetain(WordBookmark *bookmark) |
| { |
| if (bookmark != NULL) |
| bookmark->retainCount++; |
| return bookmark; |
| } |
| |
| void WordBookmarkRelease(WordBookmark *bookmark) |
| { |
| if ((bookmark == NULL) || (--bookmark->retainCount > 0)) |
| return; |
| |
| free(bookmark->bookmarkId); |
| free(bookmark->bookmarkName); |
| free(bookmark->label); |
| free(bookmark); |
| } |
| |
| void WordBookmarkAnalyze(WordBookmark *bookmark, WordSheet *sheet) |
| { |
| // FIXME: Check if the following line is still relevant with the new bookmarks model |
| if (bookmark->element == NULL) // new bookmark |
| return; |
| findTargetAndType(bookmark,sheet); |
| findLabel(bookmark); |
| } |
| |
| static void findAllNodes(DFNode *node, DFArray *result) |
| { |
| if (node->tag == WORD_PPR) |
| return; |
| for (DFNode *child = node->first; child != NULL; child = child->next) { |
| DFArrayAppend(result,child); |
| findAllNodes(child,result); |
| } |
| } |
| |
| CaptionParts WordBookmarkGetCaptionParts(WordBookmark *bookmark) |
| { |
| CaptionParts parts; |
| parts.beforeNum = 0; |
| parts.num = 0; |
| parts.afterNum = 0; |
| |
| // FIXME: Check if the following line is still relevant with the new bookmarks model |
| if (bookmark->element == NULL) |
| return parts;; |
| |
| DFArray *nodes = DFArrayNew(NULL,NULL); |
| findAllNodes(bookmark->element,nodes); |
| |
| for (size_t i = 0; i < DFArrayCount(nodes); i++) { |
| DFNode *node = DFArrayItemAt(nodes,i); |
| if (node->tag == WORD_FLDSIMPLE) { |
| const char *instr = DFGetAttribute(node,WORD_INSTR); |
| if (instr != NULL) { |
| const char **args = Word_parseField(instr); |
| if ((args[0] != NULL) && !strcmp(args[0],"SEQ")) |
| parts.num = 1; |
| free(args); |
| } |
| } |
| else if (node->tag != WORD_BOOKMARK) { |
| if (!parts.num) |
| parts.beforeNum = 1; |
| else |
| parts.afterNum = 1; |
| } |
| } |
| DFArrayRelease(nodes); |
| |
| return parts; |
| } |
| |
| void findLabel(WordBookmark *bookmark) |
| { |
| // FIXME: Not covered by tests |
| DFBuffer *buffer = DFBufferNew(); |
| for (DFNode *child = bookmark->element->first; child != NULL; child = child->next) { |
| // FIXME: handle inserted and deleted text |
| if (child->tag == WORD_R) |
| DFNodeTextToBuffer(child,buffer); |
| } |
| free(bookmark->label); |
| bookmark->label = xstrdup(buffer->data); |
| DFBufferRelease(buffer); |
| } |
| |
| static int isHeadingOutlineLvl(const char *outlineLvl) |
| { |
| if ((outlineLvl == NULL) || (strlen(outlineLvl) == 0)) |
| return 0; |
| else |
| return (atoi(outlineLvl) != 9); |
| } |
| |
| static DFNode *findPreviousElement(DFNode *node) |
| { |
| node = node->prev; |
| while ((node != NULL) && (node->tag < MIN_ELEMENT_TAG)) |
| node = node->prev; |
| return node; |
| } |
| |
| static void findTargetAndType(WordBookmark *bookmark, WordSheet *sheet) |
| { |
| if (DFStringEquals(bookmark->bookmarkName,"_GoBack")) { |
| bookmark->type = WordBookmarkCursor; |
| bookmark->target = NULL; |
| return; |
| } |
| // FIXME: Check if the following line is still relevant with the new bookmarks model |
| assert(bookmark->element != NULL); |
| DFNode *p = WordFindContainingParagraph(bookmark->element); |
| if (p == NULL) |
| return;; |
| DFNode *pPr = DFChildWithTag(p,WORD_PPR); |
| if (pPr == NULL) |
| return;; |
| DFNode *pStyle = DFChildWithTag(pPr,WORD_PSTYLE); |
| if (pStyle == NULL) |
| return;; |
| const char *styleId = DFGetAttribute(pStyle,WORD_VAL); |
| if (styleId == NULL) |
| return;; |
| WordStyle *style = WordSheetStyleForTypeId(sheet,"paragraph",styleId); |
| if ((style != NULL) && isHeadingOutlineLvl(style->outlineLvl)) { |
| bookmark->type = WordBookmarkHeading; |
| bookmark->target = p; |
| } |
| else if (DFStringEquals(styleId,"Caption")) { |
| DFNode *prev = findPreviousElement(p); |
| if (prev == NULL) |
| return; |
| |
| if (prev->tag == WORD_TBL) { |
| bookmark->type = WordBookmarkTable; |
| bookmark->target = prev; |
| } |
| else if (Word_isFigureParagraph(prev)) { |
| bookmark->type = WordBookmarkFigure; |
| bookmark->target = prev; |
| } |
| else if (Word_isEquationParagraph(prev)) { |
| bookmark->type = WordBookmarkEquation; |
| bookmark->target = prev; |
| } |
| } |
| } |
| |
| DFNode *WordFindContainingParagraph(DFNode *node) |
| { |
| while ((node != NULL) && (node->tag != WORD_P)) |
| node = node->parent; |
| return node; |
| } |
| |
| // References: String (id attribute) -> DFArray of A Element objects |
| |
| static void findReferencesRecursive(DFNode *node, DFHashTable *referencesById) |
| { |
| if (node->tag == HTML_A) { |
| const char *href = DFGetAttribute(node,HTML_HREF); |
| if ((href != NULL) && (href[0] == '#')) { |
| const char *targetId = &href[1]; |
| DFArray *links = DFHashTableLookup(referencesById,targetId); |
| if (links == NULL) { |
| links = DFArrayNew(NULL,NULL); |
| DFHashTableAdd(referencesById,targetId,links); |
| DFArrayRelease(links); |
| } |
| DFArrayAppend(links,node); |
| } |
| } |
| for (DFNode *child = node->first; child != NULL; child = child->next) |
| findReferencesRecursive(child,referencesById); |
| } |
| |
| static DFHashTable *findReferences(DFDocument *doc) |
| { |
| DFHashTable *references = DFHashTableNew((DFCopyFunction)DFArrayRetain,(DFFreeFunction)DFArrayRelease); |
| findReferencesRecursive(doc->docNode,references); |
| return references; |
| } |
| |
| static WordBookmark *createBookmark(WordPutData *put) |
| { |
| WordBookmark *bookmark = WordObjectsAddBookmark(put->conv->objects); |
| DFNode *bookmarkSpan = DFCreateElement(put->conv->html,HTML_SPAN); |
| DFSetAttribute(bookmarkSpan,HTML_CLASS,DFBookmarkClass); |
| DFSetAttribute(bookmarkSpan,WORD_NAME,bookmark->bookmarkName); |
| DFSetAttribute(bookmarkSpan,WORD_ID,bookmark->bookmarkId); |
| bookmark->element = bookmarkSpan; |
| return bookmark; |
| } |
| |
| void Word_setupBookmarkLinks(WordPutData *put) |
| { |
| DFHashTable *referencesById = findReferences(put->conv->html); |
| const char **sortedIds = DFHashTableCopyKeys(referencesById); |
| DFSortStringsCaseSensitive(sortedIds); |
| for (int idIndex = 0; sortedIds[idIndex]; idIndex++) { |
| const char *targetId = sortedIds[idIndex]; |
| DFArray *references = DFHashTableLookup(referencesById,targetId); |
| DFNode *targetElem = DFElementForIdAttr(put->conv->html,targetId); |
| if (targetElem == NULL) |
| continue; |
| |
| // The following is only relevant for figures and tables |
| int refText = 0; |
| int refLabelNum = 0; |
| int refCaptionText = 0; |
| |
| for (size_t refIndex = 0; refIndex < DFArrayCount(references); refIndex++) { |
| DFNode *a = DFArrayItemAt(references,refIndex); |
| const char *className = DFGetAttribute(a,HTML_CLASS); |
| if (DFStringEquals(className,DFRefTextClass)) |
| refText = 1; |
| else if (DFStringEquals(className,DFRefLabelNumClass)) |
| refLabelNum = 1; |
| else if (DFStringEquals(className,DFRefCaptionTextClass)) |
| refCaptionText = 1; |
| } |
| |
| DFNode *concrete = WordConverterGetConcrete(put,targetElem); |
| switch (targetElem->tag) { |
| case HTML_H1: |
| case HTML_H2: |
| case HTML_H3: |
| case HTML_H4: |
| case HTML_H5: |
| case HTML_H6: { |
| const char *bookmarkId = NULL; |
| const char *bookmarkName = NULL; |
| DFNode *bookmarkElem = NULL; |
| if ((concrete != NULL) && (concrete->tag == WORD_P)) { |
| |
| // FIXME: We only want to consider the bookmark to be the headings "correct" |
| // bookmark in the case where it contains all of the heading's content, though |
| // excluding other bookmarks that might come before or after it. |
| |
| // If you have the cursor inside a heading bookmark when you save the document, |
| // word puts a bookmark called _GoBack there, and we of course don't want to |
| // confuse that with the actual heading's bookmark (if any). |
| |
| // For now as a temporary hack we just explicitly filter out _GoBack; but there |
| // needs to be a more general fix, as there may be other bookmarks that end up |
| // in the heading. |
| |
| for (DFNode *child = concrete->first; child != NULL; child = child->next) { |
| if ((child->tag == WORD_BOOKMARK) && |
| !DFStringEquals(DFGetAttribute(child,WORD_NAME),"_GoBack")) { |
| bookmarkElem = child; |
| bookmarkId = DFGetAttribute(bookmarkElem,WORD_ID); |
| bookmarkName = DFGetAttribute(bookmarkElem,WORD_NAME); |
| break; |
| } |
| } |
| } |
| |
| if ((bookmarkElem == NULL) || (bookmarkId == NULL) || (bookmarkName == NULL)) { |
| // New bookmark |
| WordBookmark *bookmark = WordObjectsAddBookmark(put->conv->objects); |
| bookmarkId =bookmark->bookmarkId; |
| bookmarkName = bookmark->bookmarkName; |
| } |
| |
| DFNode *bookmarkSpan = DFCreateElement(put->conv->html,HTML_SPAN); |
| DFSetAttribute(bookmarkSpan,HTML_CLASS,DFBookmarkClass); |
| |
| if (bookmarkElem != NULL) { |
| // FIXME: Not covered by tests |
| DFFormatAttribute(bookmarkSpan,HTML_ID,"%s%u",put->conv->idPrefix,bookmarkElem->seqNo); |
| } |
| |
| DFSetAttribute(bookmarkSpan,WORD_NAME,bookmarkName); |
| DFSetAttribute(bookmarkSpan,WORD_ID,bookmarkId); |
| |
| while (targetElem->first != NULL) |
| DFAppendChild(bookmarkSpan,targetElem->first); |
| DFAppendChild(targetElem,bookmarkSpan); |
| |
| break; |
| } |
| case HTML_TABLE: |
| case HTML_FIGURE: { |
| WordCaption *caption = WordObjectsCaptionForTarget(put->conv->objects,targetElem); |
| if (caption == NULL) |
| break; |
| |
| assert(caption->element != NULL); |
| assert((caption->number == NULL) || (caption->number->parent == caption->element)); |
| assert((caption->contentStart == NULL) || (caption->contentStart->parent == caption->element)); |
| |
| // Note: caption.number may be null (i.e. if the caption is unnumbered) |
| // caption.contentStart may be null (if there is no text in the caption) |
| |
| WordBookmark *captionTextBookmark = NULL; |
| WordBookmark *labelNumBookmark = NULL; |
| WordBookmark *textBookmark = NULL; |
| |
| if (!refCaptionText && !refLabelNum && !refText) |
| refText = 1; |
| |
| if (refCaptionText) { |
| captionTextBookmark = createBookmark(put); |
| DFNode *nnext; |
| for (DFNode *n = caption->contentStart; n != NULL; n = nnext) { |
| nnext = n->next; |
| DFAppendChild(captionTextBookmark->element,n); |
| } |
| DFAppendChild(caption->element,captionTextBookmark->element); |
| } |
| if (refLabelNum && (caption->number != NULL)) { |
| labelNumBookmark = createBookmark(put); |
| DFNode *numberNext = caption->number->next; |
| DFNode *nnext; |
| for (DFNode *n = caption->element->first; (n != NULL) && (n != numberNext); n = nnext) { |
| nnext = n->next; |
| DFAppendChild(labelNumBookmark->element,n); |
| } |
| DFInsertBefore(caption->element,labelNumBookmark->element,caption->element->first); |
| } |
| if (refText) { |
| textBookmark = createBookmark(put); |
| DFNode *nnext; |
| for (DFNode *n = caption->element->first; n != NULL; n = nnext) { |
| nnext = n->next; |
| DFAppendChild(textBookmark->element,n); |
| } |
| DFAppendChild(caption->element,textBookmark->element); |
| } |
| |
| caption->captionTextBookmark = captionTextBookmark; |
| caption->labelNumBookmark = labelNumBookmark; |
| caption->textBookmark = textBookmark; |
| |
| break; |
| } |
| } |
| } |
| free(sortedIds); |
| DFHashTableRelease(referencesById); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // // |
| // WordRawBookmark // |
| // // |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| typedef struct WordRawBookmark WordRawBookmark; |
| |
| struct WordRawBookmark { |
| DFNode *startElement; |
| DFNode *endElement; |
| int startOffset; |
| int endOffset; |
| }; |
| |
| WordRawBookmark *WordRawBookmarkNew(void) |
| { |
| WordRawBookmark *bookmark = (WordRawBookmark *)xcalloc(1,sizeof(WordRawBookmark)); |
| bookmark->startOffset = -1; |
| bookmark->endOffset = -1; |
| return bookmark; |
| } |
| |
| void WordRawBookmarkFree(WordRawBookmark *bookmark) |
| { |
| free(bookmark); |
| } |
| |
| int WordRawBookmarkSize(WordRawBookmark *bookmark) |
| { |
| if ((bookmark->startOffset >= 0) && (bookmark->endOffset >= 0) && (bookmark->endOffset >= bookmark->startOffset)) |
| return bookmark->endOffset - bookmark->startOffset; |
| else |
| return -1; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // // |
| // Bookmark collapsing // |
| // // |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static void findBookmarkSizes(DFNode *node, DFHashTable *bookmarksById, int *offset) |
| { |
| switch (node->tag) { |
| case WORD_BOOKMARKSTART: |
| case WORD_BOOKMARKEND: { |
| const char *bookmarkId = DFGetAttribute(node,WORD_ID); |
| if (bookmarkId == NULL) |
| bookmarkId = "";; |
| WordRawBookmark *bookmark = DFHashTableLookup(bookmarksById,bookmarkId); |
| if (bookmark == NULL) { |
| bookmark = WordRawBookmarkNew(); |
| DFHashTableAdd(bookmarksById,bookmarkId,bookmark); |
| } |
| if (node->tag == WORD_BOOKMARKSTART) { |
| bookmark->startElement = node; |
| bookmark->startOffset = *offset; |
| } |
| else { |
| bookmark->endElement = node; |
| bookmark->endOffset = *offset; |
| } |
| break; |
| } |
| default: |
| (*offset)++; |
| break; |
| } |
| |
| for (DFNode *child = node->first; child != NULL; child = child->next) { |
| findBookmarkSizes(child,bookmarksById,offset); |
| } |
| } |
| |
| static int compareStartElements(void *thunk, const void *obj1, const void *obj2) |
| { |
| DFHashTable *bookmarksById = (DFHashTable *)thunk; |
| DFNode *element1 = *(DFNode **)obj1; |
| DFNode *element2 = *(DFNode **)obj2; |
| const char *id1 = DFGetAttribute(element1,WORD_ID); |
| const char *id2 = DFGetAttribute(element2,WORD_ID); |
| if (id1 == NULL) |
| id1 = ""; |
| if (id2 == NULL) |
| id2 = "";; |
| WordRawBookmark *bookmark1 = DFHashTableLookup(bookmarksById,id1); |
| WordRawBookmark *bookmark2 = DFHashTableLookup(bookmarksById,id2); |
| int size1 = WordRawBookmarkSize(bookmark1); |
| int size2 = WordRawBookmarkSize(bookmark2); |
| |
| if (size1 > size2) |
| return -1; |
| else if (size1 < size2) |
| return 1; |
| else |
| return DFStringCompare(id1,id2); |
| } |
| |
| static void collapseRecursive(DFNode *node, DFHashTable *bookmarksById) |
| { |
| |
| DFNode *next; |
| for (DFNode *child = node->first; child != NULL; child = next) { |
| next = child->next; |
| |
| switch (child->tag) { |
| case WORD_BOOKMARKSTART: |
| case WORD_BOOKMARKEND: { |
| DFArray *startElements = DFArrayNew(NULL,NULL); |
| DFArray *endElements = DFArrayNew(NULL,NULL); |
| DFHashTable *startIds = DFHashTableNew((DFCopyFunction)xstrdup,(DFFreeFunction)free); |
| DFHashTable *endIds = DFHashTableNew((DFCopyFunction)xstrdup,(DFFreeFunction)free); |
| DFNode *n; |
| for (n = child; |
| (n != NULL) && ((n->tag == WORD_BOOKMARKSTART) || (n->tag == WORD_BOOKMARKEND)); |
| n = n->next) { |
| |
| if (n->tag == WORD_BOOKMARKSTART) { |
| const char *idValue = DFGetAttribute(n,WORD_ID); |
| if (idValue == NULL) |
| idValue = ""; |
| |
| DFHashTableAdd(startIds,idValue,idValue); |
| DFArrayAppend(startElements,n); |
| } |
| else { |
| const char *idValue = DFGetAttribute(n,WORD_ID); |
| if (idValue == NULL) |
| idValue = ""; |
| |
| DFHashTableAdd(endIds,idValue,idValue); |
| DFArrayAppend(endElements,n); |
| } |
| } |
| next = n; |
| |
| DFArraySort(startElements,bookmarksById,compareStartElements); |
| |
| for (size_t endIndex = 0; endIndex < DFArrayCount(endElements); endIndex++) { |
| DFNode *elem = DFArrayItemAt(endElements,endIndex); |
| const char *endId = DFGetAttribute(elem,WORD_ID); |
| int found = 0; |
| DFNode *ancestor; |
| for (ancestor = elem->parent; (ancestor != NULL) && !found; ancestor = ancestor->parent) { |
| if ((ancestor->tag == WORD_BOOKMARK) && DFStringEquals(DFGetAttribute(ancestor,WORD_ID),endId)) { |
| found = 1; |
| break; |
| } |
| } |
| |
| if (found) { |
| DFNode *before = ancestor->next; |
| DFNode *nnext; |
| for (DFNode *n = child; n != NULL; n = nnext) { |
| nnext = n->next; |
| DFInsertBefore(ancestor->parent,n,before); |
| } |
| } |
| } |
| |
| size_t x = 0; |
| while (x < DFArrayCount(startElements)) { |
| DFNode *element = DFArrayItemAt(startElements,x); |
| const char *bookmarkId = DFGetAttribute(element,WORD_ID); |
| if (bookmarkId == NULL) |
| bookmarkId = ""; |
| if (DFHashTableLookup(endIds,bookmarkId) != NULL) { |
| element->tag = WORD_BOOKMARK; |
| DFArrayRemove(startElements,x); |
| } |
| else { |
| x++; |
| } |
| } |
| |
| if (DFArrayCount(startElements) > 0) { |
| for (size_t i = 1; i < DFArrayCount(startElements); i++) { |
| DFNode *tempParent = DFArrayItemAt(startElements,i-1); |
| DFNode *tempChild = DFArrayItemAt(startElements,i); |
| DFAppendChild(tempParent,tempChild); |
| } |
| |
| DFNode *last = DFArrayItemAt(startElements,DFArrayCount(startElements)-1); |
| while (next != NULL) { |
| DFNode *tempChild = next; |
| next = next->next; |
| DFAppendChild(last,tempChild); |
| } |
| } |
| |
| for (size_t eIndex = 0; eIndex < DFArrayCount(startElements); eIndex++) { |
| DFNode *e = DFArrayItemAt(startElements,eIndex); |
| e->tag = WORD_BOOKMARK; |
| } |
| for (size_t eIndex = 0; eIndex < DFArrayCount(endElements); eIndex++) { |
| DFNode *e = DFArrayItemAt(endElements,eIndex); |
| DFRemoveNode(e); |
| } |
| |
| if (DFArrayCount(startElements) > 0) { |
| DFNode *last = DFArrayItemAt(startElements,DFArrayCount(startElements)-1); |
| collapseRecursive(last,bookmarksById); |
| } |
| |
| DFArrayRelease(startElements); |
| DFArrayRelease(endElements); |
| DFHashTableRelease(startIds); |
| DFHashTableRelease(endIds); |
| break; |
| } |
| default: |
| collapseRecursive(child,bookmarksById); |
| break; |
| } |
| } |
| } |
| |
| static DFNode *findParagraphBackwards(DFNode *node) |
| { |
| do { |
| node = DFPrevNode(node); |
| } |
| while ((node != NULL) && (node->tag != WORD_P)); |
| return node; |
| } |
| |
| static DFNode *findParagraphForwards(DFNode *node) |
| { |
| do { |
| node = DFNextNode(node); |
| } |
| while ((node != NULL) && (node->tag != WORD_P)); |
| return node; |
| } |
| |
| static void putInParagraphsRecursive(DFNode *node) |
| { |
| DFNode *next; |
| for (DFNode *child = node->first; child != NULL; child = next) { |
| next = child->next; |
| putInParagraphsRecursive(child); |
| } |
| |
| if (((node->tag == WORD_BOOKMARKSTART) || (node->tag == WORD_BOOKMARKEND)) && |
| (node->parent->tag != WORD_P)) { |
| DFNode *forwards = findParagraphForwards(node); |
| if (forwards != NULL) { |
| DFNode *pPr = DFChildWithTag(forwards,WORD_PPR); |
| if (pPr != NULL) |
| DFInsertBefore(forwards,node,pPr->next); |
| else |
| DFInsertBefore(forwards,node,forwards->first); |
| return; |
| } |
| |
| DFNode *backwards = findParagraphBackwards(node); |
| if (backwards != NULL) { |
| DFAppendChild(backwards,node); |
| return; |
| } |
| |
| DFRemoveNode(node); |
| } |
| } |
| |
| void WordBookmarks_collapseNew(DFDocument *doc) |
| { |
| putInParagraphsRecursive(doc->docNode); |
| DFHashTable *bookmarksById = DFHashTableNew(NULL,(DFFreeFunction)WordRawBookmarkFree); |
| int offset = 0; |
| findBookmarkSizes(doc->root,bookmarksById,&offset); |
| collapseRecursive(doc->root,bookmarksById); |
| DFHashTableRelease(bookmarksById); |
| } |
| |
| static void expandRecursive(DFNode *node) |
| { |
| DFNode *next; |
| for (DFNode *child = node->first; child != NULL; child = next) { |
| next = child->next; |
| expandRecursive(child); |
| } |
| |
| if (node->tag == WORD_BOOKMARK) { |
| const char *bookmarkId = DFGetAttribute(node,WORD_ID); |
| const char *bookmarkName = DFGetAttribute(node,WORD_NAME); |
| if (bookmarkId == NULL) |
| bookmarkId = ""; |
| if (bookmarkName == NULL) |
| bookmarkName = "";; |
| DFNode *startElem = DFCreateElement(node->doc,WORD_BOOKMARKSTART); |
| DFNode *endElem = DFCreateElement(node->doc,WORD_BOOKMARKEND); |
| DFSetAttribute(startElem,WORD_ID,bookmarkId); |
| DFSetAttribute(startElem,WORD_NAME,bookmarkName); |
| DFSetAttribute(endElem,WORD_ID,bookmarkId); |
| DFInsertBefore(node->parent,startElem,node); |
| DFInsertBefore(node->parent,endElem,node->next); |
| DFRemoveNodeButKeepChildren(node); |
| } |
| } |
| |
| void WordBookmarks_expandNew(DFDocument *doc) |
| { |
| expandRecursive(doc->docNode); |
| } |
| |
| static void removeCaptionBookmarksRecursive(DFNode *node, int inCaption) |
| { |
| if (node->tag == WORD_P) { |
| DFNode *pPr = DFChildWithTag(node,WORD_PPR); |
| const char *styleId = DFGetChildAttribute(pPr,WORD_PSTYLE,WORD_VAL); |
| if (DFStringEquals(styleId,"Caption")) |
| inCaption = 1; |
| } |
| |
| DFNode *next; |
| for (DFNode *child = node->first; child != NULL; child = next) { |
| next = child->next; |
| removeCaptionBookmarksRecursive(child,inCaption); |
| } |
| |
| if (inCaption) { |
| switch (node->tag) { |
| case WORD_BOOKMARKSTART: |
| case WORD_BOOKMARKEND: |
| case WORD_BOOKMARK: |
| DFRemoveNodeButKeepChildren(node); |
| break; |
| } |
| } |
| } |
| |
| void WordBookmarks_removeCaptionBookmarks(DFDocument *doc) |
| { |
| removeCaptionBookmarksRecursive(doc->docNode,0); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // // |
| // WordBookmarkLens // |
| // // |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static int WordBookmarkIsVisible2(DFNode *concrete); |
| |
| static DFNode *WordBookmarkGet(WordGetData *get, DFNode *concrete) |
| { |
| if (!WordBookmarkIsVisible2(concrete)) |
| return NULL;; |
| DFNode *abstract = WordConverterCreateAbstract(get,HTML_SPAN,concrete); |
| DFSetAttribute(abstract,HTML_CLASS,DFBookmarkClass); |
| WordContainerGet(get,&WordParagraphContentLens,abstract,concrete); |
| return abstract; |
| } |
| |
| static int WordBookmarkIsVisible2(DFNode *concrete) |
| { |
| const char *name = DFGetAttribute(concrete,WORD_NAME); |
| |
| if (name == NULL) |
| return 0; |
| |
| if (DFStringEquals(name,"_GoBack") && (concrete->first == NULL)) |
| return 0; |
| |
| return 1; |
| } |
| |
| static int WordBookmarkIsVisible(WordPutData *put, DFNode *concrete) |
| { |
| return WordBookmarkIsVisible2(concrete); |
| } |
| |
| static void WordBookmarkPut(WordPutData *put, DFNode *abstract, DFNode *concrete) |
| { |
| WordContainerPut(put,&WordParagraphContentLens,abstract,concrete); |
| } |
| |
| static void WordBookmarkRemove(WordPutData *put, DFNode *concrete) |
| { |
| for (DFNode *child = concrete->first; child != NULL; child = child->next) |
| WordParagraphContentLens.remove(put,child); |
| } |
| |
| WordLens WordBookmarkLens = { |
| .isVisible = WordBookmarkIsVisible, |
| .get = WordBookmarkGet, |
| .put = WordBookmarkPut, |
| .create = NULL, // LENS FIXME |
| .remove = WordBookmarkRemove, |
| }; |
