| // 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 "DFHTML.h" |
| #include "DFFilesystem.h" |
| #include "DFDOM.h" |
| #include "CSS.h" |
| #include "CSSProperties.h" |
| #include "CSSSelector.h" |
| #include "CSSLength.h" |
| #include "CSSSheet.h" |
| #include "DFHTDocument.h" |
| #include "DFTidyHelper.h" |
| #include "DFNameMap.h" |
| #include "DFXML.h" |
| #include "DFString.h" |
| #include "DFCharacterSet.h" |
| #include "DFCommon.h" |
| |
| static DFNode *HTML_findHead(DFDocument *doc) |
| { |
| for (DFNode *child1 = doc->docNode->first; child1 != NULL; child1 = child1->next) { |
| if (child1->tag != HTML_HTML) |
| return NULL; |
| for (DFNode *child2 = child1->first; child2 != NULL; child2 = child2->next) { |
| if (child2->tag == HTML_HEAD) { |
| return child2; |
| } |
| } |
| } |
| return NULL; |
| } |
| |
| void HTMLAddExternalStyleSheet(DFDocument *doc, const char *href) |
| { |
| DFNode *head = HTML_findHead(doc); |
| if (head == NULL) |
| return;; |
| DFNode *link = DFCreateElement(doc,HTML_LINK); |
| DFSetAttribute(link,HTML_REL,"stylesheet"); |
| DFSetAttribute(link,HTML_HREF,href); |
| DFAppendChild(head,link); |
| } |
| |
| void HTMLAddInternalStyleSheet(DFDocument *doc, const char *cssText) |
| { |
| DFNode *head = HTML_findHead(doc); |
| if (head == NULL) |
| return;; |
| DFNode *style = DFCreateElement(doc,HTML_STYLE); |
| DFAppendChild(style,DFCreateTextNode(doc,cssText)); |
| DFAppendChild(head,style); |
| } |
| |
| char *HTMLCopyCSSText(DFDocument *doc) |
| { |
| DFNode *head = DFChildWithTag(doc->root,HTML_HEAD); |
| if (head == NULL) |
| return xstrdup("");; |
| DFNode *style = DFChildWithTag(head,HTML_STYLE); |
| if (style == NULL) |
| return xstrdup(""); |
| return DFNodeTextToString(style); |
| } |
| |
| int HTML_isContainerTag(Tag tag) |
| { |
| switch (tag) { |
| case HTML_ARTICLE: |
| case HTML_SECTION: |
| case HTML_NAV: |
| case HTML_ASIDE: |
| case HTML_HGROUP: |
| case HTML_HEADER: |
| case HTML_FOOTER: |
| case HTML_ADDRESS: |
| case HTML_DIV: |
| return 1; |
| default: |
| return 0; |
| } |
| } |
| |
| int HTML_isBlockLevelTag(Tag tag) |
| { |
| switch (tag) { |
| case HTML_H1: |
| case HTML_H2: |
| case HTML_H3: |
| case HTML_H4: |
| case HTML_H5: |
| case HTML_H6: |
| case HTML_P: |
| case HTML_UL: |
| case HTML_OL: |
| case HTML_LI: |
| case HTML_TABLE: |
| case HTML_CAPTION: |
| case HTML_TR: |
| case HTML_TD: |
| case HTML_TH: |
| case HTML_THEAD: |
| case HTML_TBODY: |
| case HTML_TFOOT: |
| case HTML_FIGURE: |
| case HTML_FIGCAPTION: |
| return 1; |
| default: |
| return HTML_isContainerTag(tag); |
| } |
| } |
| |
| int HTML_isParagraphTag(Tag tag) |
| { |
| switch (tag) { |
| case HTML_H1: |
| case HTML_H2: |
| case HTML_H3: |
| case HTML_H4: |
| case HTML_H5: |
| case HTML_H6: |
| case HTML_P: |
| return 1; |
| default: |
| return 0; |
| } |
| } |
| |
| int HTML_isListTag(Tag tag) |
| { |
| switch (tag) { |
| case HTML_UL: |
| case HTML_OL: |
| return 1; |
| default: |
| return 0; |
| } |
| } |
| |
| int HTML_isSpecialSpan(DFNode *node) |
| { |
| if (node->tag != HTML_SPAN) |
| return 0; |
| return DFStringHasPrefix(DFGetAttribute(node,HTML_CLASS),"uxwrite-"); |
| } |
| |
| int HTML_isContentNode(DFNode *node) |
| { |
| switch (node->tag) { |
| case DOM_TEXT: |
| return 1; |
| case HTML_SPAN: |
| return HTML_isSpecialSpan(node); |
| case HTML_IMG: |
| return 1; |
| case HTML_BR: |
| return 1; |
| default: |
| return 0; |
| } |
| } |
| |
| int HTML_nodeHasContent(DFNode *node) |
| { |
| if (DFIsWhitespaceNode(node)) |
| return 0; |
| if (HTML_isContentNode(node)) |
| return 1; |
| for (DFNode *child = node->first; child != NULL; child = child->next) { |
| if (HTML_nodeHasContent(child)) |
| return 1; |
| } |
| return 0; |
| } |
| |
| int HTML_nodeIsHyperlink(DFNode *node) |
| { |
| const char *href = DFGetAttribute(node,HTML_HREF); |
| return ((node->tag == HTML_A) && (href != NULL) && !DFStringHasPrefix(href,"#")); |
| } |
| |
| static char *indentString(int depth) |
| { |
| char *str = (char *)xmalloc(1+depth*2+1); |
| str[0] = '\n'; |
| memset(&str[1],' ',depth*2); |
| str[1+depth*2] = '\0'; |
| return str; |
| } |
| |
| static DFNode *createIndentNode(DFDocument *doc, int depth) |
| { |
| char *str = indentString(depth); |
| DFNode *node = DFCreateTextNode(doc,str); |
| free(str); |
| return node; |
| } |
| |
| void HTML_safeIndent(DFNode *node, int depth) |
| { |
| switch (node->tag) { |
| case DOM_DOCUMENT: |
| case HTML_HTML: |
| case HTML_HEAD: |
| case HTML_BODY: |
| case HTML_DIV: |
| case HTML_UL: |
| case HTML_OL: |
| case HTML_LI: |
| case HTML_NAV: |
| case HTML_FIGURE: |
| case HTML_TABLE: |
| case HTML_COLGROUP: |
| case HTML_THEAD: |
| case HTML_TBODY: |
| case HTML_TFOOT: |
| case HTML_TR: |
| case HTML_TH: |
| case HTML_TD: { |
| DFNode *next; |
| for (DFNode *child = node->first; child != NULL; child = next) { |
| next = child->next; |
| DFNode *text = createIndentNode(node->doc,depth); |
| DFInsertBefore(node,text,child); |
| } |
| if (node->tag != DOM_DOCUMENT) { |
| DFNode *text = createIndentNode(node->doc,depth-1); |
| DFAppendChild(node,text); |
| } |
| break; |
| } |
| case HTML_SCRIPT: |
| case HTML_STYLE: { |
| char *nodeContent = DFNodeTextToString(node); |
| char *trimmedContent = DFStringTrimWhitespace(nodeContent); |
| while (node->first != NULL) |
| DFRemoveNode(node->first); |
| char *indentStr = indentString(depth-1); |
| char *revisedStr = DFFormatString("\n%s%s",trimmedContent,indentStr); |
| DFAppendChild(node,DFCreateTextNode(node->doc,revisedStr)); |
| free(indentStr); |
| free(revisedStr); |
| free(nodeContent); |
| free(trimmedContent); |
| break; |
| } |
| case HTML_H1: |
| case HTML_H2: |
| case HTML_H3: |
| case HTML_H4: |
| case HTML_H5: |
| case HTML_H6: |
| case HTML_P: |
| case HTML_FIGCAPTION: |
| case HTML_CAPTION: { |
| if (node->first != NULL) { |
| char *indentBefore = indentString(depth); |
| char *indentAfter = indentString(depth-1); |
| DFNode *before = DFCreateTextNode(node->doc,indentBefore); |
| DFNode *after = DFCreateTextNode(node->doc,indentAfter); |
| DFInsertBefore(node,before,node->first); |
| DFAppendChild(node,after); |
| free(indentBefore); |
| free(indentAfter); |
| } |
| break; |
| } |
| } |
| DFNode *next; |
| for (DFNode *child = node->first; child != NULL; child = next) { |
| next = child->next; |
| HTML_safeIndent(child,depth+1); |
| } |
| } |
| |
| void HTMLBreakBDTRefs(DFNode *node, const char *idPrefix) |
| { |
| if (node->tag >= MIN_ELEMENT_TAG) { |
| const char *seqNo = DFGetAttribute(node,HTML_ID); |
| if ((seqNo != NULL) && DFStringHasPrefix(seqNo,idPrefix)) { |
| char *newNodeId = DFFormatString("x%s",&seqNo[strlen(idPrefix)]); |
| DFSetAttribute(node,HTML_ID,newNodeId); |
| free(newNodeId); |
| } |
| } |
| for (DFNode *child = node->first; child != NULL; child = child->next) |
| HTMLBreakBDTRefs(child,idPrefix); |
| } |
| |
| CSSSize HTML_getImageDimensions(DFNode *img) |
| { |
| CSSSize dimensions; |
| bzero(&dimensions,sizeof(CSSSize)); |
| |
| const char *styleAttr = DFGetAttribute(img,HTML_STYLE); |
| if (styleAttr != NULL) { |
| CSSProperties *properties = CSSPropertiesNewWithString(styleAttr); |
| if (CSSGet(properties,"width") != NULL) |
| dimensions.width = CSSLengthFromString(CSSGet(properties,"width")); |
| if (CSSGet(properties,"height") != NULL) |
| dimensions.height = CSSLengthFromString(CSSGet(properties,"height")); |
| CSSPropertiesRelease(properties); |
| } |
| |
| if (!CSSLengthIsValid(dimensions.width)) { |
| const char *widthAttr = DFGetAttribute(img,HTML_WIDTH); |
| if (widthAttr != NULL) { |
| if (DFStringHasSuffix(widthAttr,"%")) |
| dimensions.width = CSSLengthFromValue(atof(widthAttr),UnitsPct); |
| else |
| dimensions.width = CSSLengthFromValue(atof(widthAttr),UnitsPx); |
| } |
| } |
| |
| if (CSSLengthIsValid(dimensions.height)) { |
| const char *heightAttr = DFGetAttribute(img,HTML_HEIGHT); |
| if (heightAttr != NULL) { |
| if (DFStringHasSuffix(heightAttr,"%")) |
| dimensions.height = CSSLengthFromValue(atof(heightAttr),UnitsPct); |
| else |
| dimensions.height = CSSLengthFromValue(atof(heightAttr),UnitsPx); |
| } |
| } |
| |
| return dimensions; |
| } |
| |
| int isRRGGBB(const char *str) |
| { |
| if (str == NULL) |
| return 0;; |
| |
| size_t len = strlen(str); |
| if (len != 6) |
| return 0; |
| |
| for (size_t i = 0; i < len; i++) { |
| if (!DFCharIsHex(str[i])) |
| return 0; |
| } |
| |
| return 1; |
| } |
| |
| int isHashRRGGBB(const char *str) |
| { |
| return (strlen(str) == 7) && (str[0] == '#') && isRRGGBB(&str[1]); |
| } |
| |
| const char *HTMLMetaGet(DFDocument *htmlDoc, const char *name) |
| { |
| assert(htmlDoc->root != NULL); |
| assert(htmlDoc->root->tag == HTML_HTML); |
| DFNode *head = DFChildWithTag(htmlDoc->root,HTML_HEAD); |
| if (head == NULL) |
| return NULL; |
| for (DFNode *meta = head->first; meta != NULL; meta = meta->next) { |
| if ((meta->tag == HTML_META) && DFStringEquals(DFGetAttribute(meta,HTML_NAME),name)) |
| return DFGetAttribute(meta,HTML_CONTENT); |
| } |
| return NULL; |
| } |
| |
| void HTMLMetaSet(DFDocument *htmlDoc, const char *name, const char *content) |
| { |
| assert(htmlDoc->root != NULL); |
| assert(htmlDoc->root->tag == HTML_HTML); |
| DFNode *head = DFChildWithTag(htmlDoc->root,HTML_HEAD); |
| if (head == NULL) { |
| head = DFCreateElement(htmlDoc,HTML_HEAD); |
| DFNode *body = DFChildWithTag(htmlDoc->root,HTML_BODY); |
| DFInsertBefore(htmlDoc->root,head,body); |
| } |
| for (DFNode *meta = head->first; meta != NULL; meta = meta->next) { |
| if ((meta->tag == HTML_META) && DFStringEquals(DFGetAttribute(meta,HTML_NAME),name)) { |
| DFSetAttribute(meta,HTML_CONTENT,content); |
| return; |
| } |
| } |
| DFNode *meta = DFCreateChildElement(head,HTML_META); |
| DFSetAttribute(meta,HTML_NAME,name); |
| DFSetAttribute(meta,HTML_CONTENT,content); |
| } |
| |
| void HTMLMetaRemove(DFDocument *htmlDoc, const char *name) |
| { |
| assert(htmlDoc->root != NULL); |
| assert(htmlDoc->root->tag == HTML_HTML); |
| DFNode *head = DFChildWithTag(htmlDoc->root,HTML_HEAD); |
| if (head == NULL) |
| return;; |
| DFNode *next; |
| for (DFNode *meta = head->first; meta != NULL; meta = next) { |
| next = meta->next; |
| if ((meta->tag == HTML_META) && DFStringEquals(DFGetAttribute(meta,HTML_NAME),name)) |
| DFRemoveNode(meta); |
| } |
| } |
| |
| DFDocument *DFParseHTMLString(const char *str, int removeSpecial, DFError **error) |
| { |
| DFHTDocument *htdoc = DFHTDocumentNew(); |
| // printf("tidy option nl = %d\n",tidyOptGetInt(htdoc.doc,TidyNewline)); |
| // tidyOptSetInt(htdoc.doc,TidyNewline,1); |
| if (!DFHTDocumentParseCString(htdoc,str,error)) { |
| DFHTDocumentFree(htdoc); |
| return NULL; |
| } |
| if (removeSpecial) |
| DFHTDocumentRemoveUXWriteSpecial(htdoc);; |
| DFDocument *doc = DFDocumentNew(); |
| DFNode *root = fromTidyNode(doc,htdoc->doc,tidyGetHtml(htdoc->doc)); |
| if (root == NULL) { |
| DFErrorFormat(error,"No root element"); |
| DFDocumentRelease(doc); |
| DFHTDocumentFree(htdoc); |
| return NULL; |
| } |
| DFAppendChild(doc->docNode,root); |
| doc->root = root; |
| |
| // Remove empty title element that is automatically added by HTMLTidy's parser, since a lot of |
| // tests currently depend on it not being present |
| DFNode *head = DFChildWithTag(doc->root,HTML_HEAD); |
| if (head != NULL) { |
| DFNode *title = DFChildWithTag(head,HTML_TITLE); |
| if (title != NULL) { |
| char *titleText = DFNodeTextToString(title); |
| if (strlen(titleText) == 0) |
| DFRemoveNode(title); |
| free(titleText); |
| } |
| } |
| |
| DFHTDocumentFree(htdoc); |
| return doc; |
| } |
| |
| DFDocument *DFParseHTMLFile(const char *filename, int removeSpecial, DFError **error) |
| { |
| DFBuffer *buf = DFBufferReadFromFile(filename,error); |
| if (buf == NULL) |
| return NULL;; |
| DFDocument *doc = DFParseHTMLString(buf->data,removeSpecial,error); |
| DFBufferRelease(buf); |
| return doc; |
| } |
| |
| static void DFHTMLGetImagesRecursive(DFNode *node, DFHashTable *images) |
| { |
| if (node->tag == HTML_IMG) { |
| const char *src = DFGetAttribute(node,HTML_SRC); |
| if (src != NULL) { |
| char *decoded = DFRemovePercentEncoding(src); |
| DFHashTableAdd(images,decoded,""); |
| free(decoded); |
| } |
| } |
| else { |
| for (DFNode *child = node->first; child != NULL; child = child->next) |
| DFHTMLGetImagesRecursive(child,images); |
| } |
| } |
| |
| const char **DFHTMLGetImages(DFDocument *htmlDoc) |
| { |
| DFHashTable *images = DFHashTableNew(NULL,NULL); |
| DFHTMLGetImagesRecursive(htmlDoc->root,images); |
| const char **filenames = DFHashTableCopyKeys(images); |
| DFSortStringsCaseInsensitive(filenames); |
| DFHashTableRelease(images); |
| return filenames; |
| } |
