| // 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 "CSSClassNames.h" |
| #include "CSS.h" |
| #include "CSSProperties.h" |
| #include "CSSStyle.h" |
| #include "CSSSheet.h" |
| #include "DFDOM.h" |
| #include "DFXML.h" |
| #include "DFNameMap.h" |
| #include "DFString.h" |
| #include "DFHashTable.h" |
| #include "DFHTML.h" |
| #include "WordStyles.h" |
| #include "Word.h" |
| #include "DFCommon.h" |
| #include "DFPlatform.h" |
| #include <stdlib.h> |
| #include <string.h> |
| |
| static const char *classPrefixForElementName(const char *elementName); |
| |
| static void ensureStylesReferencedFromNode(DFNode *node, CSSSheet *styleSheet) |
| { |
| switch (node->tag) { |
| case HTML_H1: |
| case HTML_H2: |
| case HTML_H3: |
| case HTML_H4: |
| case HTML_H5: |
| case HTML_H6: |
| case HTML_P: |
| case HTML_FIGURE: { |
| char *selector = CSSMakeNodeSelector(node); |
| CSSSheetLookupSelector(styleSheet,selector,1,0); |
| free(selector); |
| break; |
| } |
| case HTML_A: { |
| if (HTML_nodeIsHyperlink(node)) { |
| CSSStyle *style = CSSSheetLookupElement(styleSheet,"span","Hyperlink",0,0); |
| if (style == NULL) { |
| style = CSSSheetLookupElement(styleSheet,"span","Hyperlink",1,0); |
| CSSPut(CSSStyleRule(style),"color","#0000FF"); |
| CSSSetUnderline(CSSStyleRule(style),1); |
| |
| CSSStyle *parent = CSSSheetDefaultStyleForFamily(styleSheet,StyleFamilyCharacter); |
| if (parent != NULL) |
| CSSStyleSetParent(style,parent->selector); |
| } |
| } |
| break; |
| } |
| case HTML_TABLE: { |
| const char *className = DFGetAttribute(node,HTML_CLASS); |
| if (className == NULL) { |
| CSSStyle *dflt = CSSSheetDefaultStyleForFamily(styleSheet,StyleFamilyTable); |
| int changed = 0; |
| CSSStyle *grid = WordSetupTableGridStyle(styleSheet,&changed); |
| DFSetAttribute(node,HTML_CLASS,grid->className); |
| |
| // Copy over cell padding rules. These are not automatically inherited in Word, and must be |
| // explicitly duplicated for each descendant of the TableNormal style. |
| |
| // Under normal circumstances, when the user has added a table in the editor, the TableGrid |
| // style will already be defined, with the appropriate padding rules set in the document's |
| // stylesheet, and StyleSheet.removeRedundantProperties will make sure that each table style |
| // keeps the padding properties. However if we are creating a HTML file that was not |
| // oringally created with the intention of being converted to a word document, the TableGrid |
| // style will not exist, and must be created. In this case (i.e. where changed is true) we |
| // have to explicitly copy these properties over. |
| |
| if (changed) { |
| CSSPut(CSSStyleCell(grid),"padding-left",CSSGet(CSSStyleCell(dflt),"padding-left")); |
| CSSPut(CSSStyleCell(grid),"padding-right",CSSGet(CSSStyleCell(dflt),"padding-right")); |
| CSSPut(CSSStyleCell(grid),"padding-top",CSSGet(CSSStyleCell(dflt),"padding-top")); |
| CSSPut(CSSStyleCell(grid),"padding-bottom",CSSGet(CSSStyleCell(dflt),"padding-bottom")); |
| } |
| } |
| break; |
| } |
| } |
| for (DFNode *child = node->first; child != NULL; child = child->next) |
| ensureStylesReferencedFromNode(child,styleSheet); |
| } |
| |
| void CSSEnsureReferencedStylesPresent(DFDocument *htmlDoc, CSSSheet *styleSheet) |
| { |
| CSSSheetLookupSelector(styleSheet,"p",1,0); |
| ensureStylesReferencedFromNode(htmlDoc->root,styleSheet); |
| } |
| |
| static void addHTMLDefaults(CSSStyle *style, CSSStyle *parent) |
| { |
| if (style->headingLevel > 0) { |
| const char *fontWeight = NULL; |
| const char *fontSize = NULL; |
| |
| switch (style->tag) { |
| case HTML_H1: |
| fontWeight = "bold"; |
| fontSize = "24pt"; |
| break; |
| case HTML_H2: |
| fontWeight = "bold"; |
| fontSize = "18pt"; |
| break; |
| case HTML_H3: |
| fontWeight = "bold"; |
| fontSize = "14pt"; |
| break; |
| case HTML_H4: |
| fontWeight = "bold"; |
| fontSize = "12pt"; |
| break; |
| case HTML_H5: |
| fontWeight = "bold"; |
| fontSize = "10pt"; |
| break; |
| case HTML_H6: |
| fontWeight = "bold"; |
| fontSize = "8pt"; |
| break; |
| } |
| |
| CSSProperties *properties = CSSStyleRule(style); |
| if ((CSSGet(properties,"font-weight") == NULL) && ((parent == NULL) || (CSSGet(CSSStyleRule(parent),"font-weight") == NULL))) |
| CSSPut(properties,"font-weight",fontWeight); |
| if ((CSSGet(properties,"font-size") == NULL) && ((parent == NULL) || (CSSGet(CSSStyleRule(parent),"font-size") == NULL))) |
| CSSPut(properties,"font-size",fontSize); |
| // FIXME: This likely differs between languages |
| // FIXME: Not covered by tests |
| char *styleNext = CSSStyleCopyNext(style); |
| char *parentNext = (parent != NULL) ? CSSStyleCopyNext(parent) : NULL; |
| if ((styleNext == NULL) && ((parent == NULL) || (parentNext == NULL))) |
| CSSStyleSetNext(style,"p.Normal"); |
| free(styleNext); |
| free(parentNext); |
| } |
| } |
| |
| void CSSSetHTMLDefaults(CSSSheet *styleSheet) |
| { |
| // For any heading elements that have an unnamed style declaration, set the default HTML properties on that. |
| // All named style declarations inherit from these. |
| |
| // For any heading elements that have only named style declarations, set the default HTML properties on each |
| // of them individually. |
| |
| for (int i = 1; i <= 6; i++) { |
| char *elementName = DFFormatString("h%d",i); |
| CSSStyle *style = CSSSheetLookupElement(styleSheet,elementName,NULL,0,0); |
| if (style != NULL) |
| addHTMLDefaults(style,NULL); |
| free(elementName); |
| } |
| |
| const char **allSelectors = CSSSheetCopySelectors(styleSheet); |
| for (int i = 0; allSelectors[i]; i++) { |
| const char *selector = allSelectors[i]; |
| |
| if (CSSSelectorIsHeading(selector) && (CSSSelectorHasClassName(selector))) { |
| char *elementName = CSSSelectorCopyElementName(selector); |
| |
| CSSStyle *namedStyle = CSSSheetLookupSelector(styleSheet,selector,0,0); |
| CSSStyle *unnamedStyle = CSSSheetLookupSelector(styleSheet,elementName,0,0); |
| CSSStyle *flattened = NULL; |
| CSSStyle *parent = CSSSheetGetStyleParent(styleSheet,namedStyle); |
| if (parent != NULL) |
| flattened = CSSSheetFlattenedStyle(styleSheet,parent); |
| |
| if (unnamedStyle == NULL) |
| addHTMLDefaults(namedStyle,flattened); |
| |
| CSSStyleRelease(flattened); |
| free(elementName); |
| } |
| } |
| free(allSelectors); |
| } |
| |
| static void setMissingDisplayNames(CSSSheet *styleSheet) |
| { |
| const char **allSelectors = CSSSheetCopySelectors(styleSheet); |
| for (int i = 0; allSelectors[i]; i++) { |
| CSSStyle *style = CSSSheetLookupSelector(styleSheet,allSelectors[i],0,0); |
| char *className = NULL; |
| char *displayName = CSSStyleCopyDisplayName(style); |
| if ((style->headingLevel > 0) && (displayName == NULL)) { |
| const char *defaultClass = classPrefixForElementName(style->elementName); |
| |
| if ((style->className != NULL) && (defaultClass != NULL) && DFStringHasPrefix(style->className,defaultClass)) |
| className = DFSubstring(style->className,strlen(defaultClass),strlen(style->className)); |
| else |
| className = DFStrDup(style->className); |
| |
| if ((className != NULL) && strlen(className) > 0) |
| displayName = DFFormatString("Heading %d (%s)",style->headingLevel,className); |
| else |
| displayName = DFFormatString("heading %d",style->headingLevel); |
| CSSStyleSetDisplayName(style,displayName); |
| } |
| free(displayName); |
| free(className); |
| } |
| free(allSelectors); |
| } |
| |
| static void setParentForHeadings(CSSSheet *styleSheet, DFHashTable *repls) |
| { |
| const char **allSelectors = CSSSheetCopySelectors(styleSheet); |
| for (int i = 0; allSelectors[i]; i++) { |
| const char *selector = allSelectors[i]; |
| if (!CSSSelectorIsHeading(selector)) |
| continue; |
| |
| CSSStyle *style = CSSSheetLookupSelector(styleSheet,selector,0,0); |
| const char *defaultClass = classPrefixForElementName(style->elementName); |
| if (defaultClass == NULL) |
| continue; |
| |
| CSSStyle *parentStyle = CSSSheetLookupElement(styleSheet,style->elementName,defaultClass,0,0); |
| if ((parentStyle != NULL) && (parentStyle != style)) |
| CSSStyleSetParent(style,parentStyle->selector); |
| } |
| free(allSelectors); |
| } |
| |
| static const char *classPrefixForElementName(const char *elementName) |
| { |
| if (!strcmp(elementName,"h1")) |
| return "heading_1"; |
| else if (!strcmp(elementName,"h2")) |
| return "heading_2"; |
| else if (!strcmp(elementName,"h3")) |
| return "heading_3"; |
| else if (!strcmp(elementName,"h4")) |
| return "heading_4"; |
| else if (!strcmp(elementName,"h5")) |
| return "heading_5"; |
| else if (!strcmp(elementName,"h6")) |
| return "heading_6"; |
| else |
| return elementName; |
| } |
| |
| static void determineReplacements(CSSSheet *styleSheet, DFHashTable *repls) |
| { |
| // char * -> linked list of SelectorList nodes |
| DFHashTable *selectorsByClassName = DFHashTableNew(NULL,NULL); |
| |
| const char **allSelectors = CSSSheetCopySelectors(styleSheet); |
| for (int i = 0; allSelectors[i]; i++) { |
| const char *selector = allSelectors[i]; |
| char *className = CSSSelectorCopyClassName(selector); |
| if (className == NULL) |
| className = xstrdup("");; |
| |
| SelectorList *item = (SelectorList *)xcalloc(1,sizeof(SelectorList)); |
| item->selector = xstrdup(selector); |
| item->next = DFHashTableLookup(selectorsByClassName,className); |
| DFHashTableAdd(selectorsByClassName,className,item); |
| free(className); |
| } |
| free(allSelectors); |
| |
| const char **allClasses = DFHashTableCopyKeys(selectorsByClassName); |
| for (int i = 0; allClasses[i]; i++) { |
| const char *className = allClasses[i]; |
| SelectorList *list = DFHashTableLookup(selectorsByClassName,className); |
| SelectorList *start = list; |
| SelectorList *next; |
| for (; list != NULL; list = next) { |
| next = list->next; |
| const char *oldSelector = list->selector; |
| char *elementName = CSSSelectorCopyElementName(oldSelector); |
| int haveUnnamed = (CSSSheetLookupSelector(styleSheet,elementName,0,0) != NULL); |
| if (((start != NULL) && (start->next != NULL)) || !strcmp(className,"") || haveUnnamed) { |
| if (CSSSelectorIsHeading(oldSelector)) { |
| const char *prefix = classPrefixForElementName(elementName); |
| char *newSelector = DFFormatString("%s.%s%s",elementName,prefix,className); |
| DFHashTableAdd(repls,oldSelector,newSelector); |
| free(newSelector); |
| } |
| } |
| free(elementName); |
| } |
| |
| // Free selector list |
| for (list = start; list != NULL; list = next) { |
| next = list->next; |
| free(list->selector); |
| free(list); |
| } |
| } |
| free(allClasses); |
| DFHashTableRelease(selectorsByClassName); |
| |
| // Remove any "double replacements", where the new selector is itself a key in the hash table, e.g.: |
| // h1 -> h1.Heading1 -> h1.Heading1Heading1 |
| // |
| // This avoids a problem where a style is renamed twice, but the relevant nodes in the DOM tree are only updated |
| // to refer to the first replacement, not the second, causing an assertion failure in WordParagraphPut, which |
| // expects there to be a style for every selector it encounters during traversal. |
| const char **allOldSelectors = DFHashTableCopyKeys(repls); |
| for (int i = 0; allOldSelectors[i]; i++) { |
| const char *newSelector = DFHashTableLookup(repls,allOldSelectors[i]); |
| if (newSelector != NULL) // may have already been removed |
| DFHashTableRemove(repls,newSelector); |
| } |
| free(allOldSelectors); |
| } |
| |
| static void replaceSelectorsInNode(DFHashTable *repls, DFNode *node) |
| { |
| switch (node->tag) { |
| case HTML_H1: |
| case HTML_H2: |
| case HTML_H3: |
| case HTML_H4: |
| case HTML_H5: |
| case HTML_H6: { |
| const char *className = DFGetAttribute(node,HTML_CLASS); |
| char *oldSelector = CSSMakeTagSelector(node->tag,className); |
| const char *newSelector = DFHashTableLookup(repls,oldSelector); |
| |
| if (newSelector != NULL) { |
| char *className = CSSSelectorCopyClassName(newSelector); |
| DFSetAttribute(node,HTML_CLASS,className); |
| free(className); |
| } |
| |
| free(oldSelector); |
| break; |
| } |
| } |
| for (DFNode *child = node->first; child != NULL; child = child->next) |
| replaceSelectorsInNode(repls,child); |
| } |
| |
| static void replaceSelectorsInSheet(DFHashTable *repls, CSSSheet *styleSheet) |
| { |
| const char **allSelectors = CSSSheetCopySelectors(styleSheet); |
| for (int i = 0; allSelectors[i]; i++) { |
| const char *oldSelector = allSelectors[i]; |
| const char *newSelector = DFHashTableLookup(repls,oldSelector); |
| if ((newSelector == NULL) || !strcmp(newSelector,oldSelector)) |
| continue; |
| |
| CSSStyle *style = CSSSheetLookupSelector(styleSheet,oldSelector,0,0); |
| CSSStyle *existing = CSSSheetLookupSelector(styleSheet,newSelector,0,0); |
| |
| if (existing != NULL) { |
| CSSSheetRemoveStyle(styleSheet,style); |
| } |
| else { |
| // We must retain a reference to the style here, otherwise it will be deleted when removed from the sheet |
| CSSStyleRetain(style); |
| CSSSheetRemoveStyle(styleSheet,style); |
| CSSStyleSetSelector(style,newSelector); |
| CSSSheetAddStyle(styleSheet,style); |
| CSSStyleRelease(style); |
| } |
| } |
| free(allSelectors); |
| |
| // FIXME: Not covered by tests |
| allSelectors = CSSSheetCopySelectors(styleSheet); |
| for (int i = 0; allSelectors[i]; i++) { |
| CSSStyle *style = CSSSheetLookupSelector(styleSheet,allSelectors[i],0,0); |
| |
| char *parentSelector = CSSStyleCopyParent(style); |
| if ((parentSelector != NULL) && (DFHashTableLookup(repls,parentSelector) != NULL)) |
| CSSStyleSetParent(style,DFHashTableLookup(repls,parentSelector)); |
| free(parentSelector); |
| |
| char *nextSelector = CSSStyleCopyNext(style); |
| if ((nextSelector != NULL) && (DFHashTableLookup(repls,nextSelector) != NULL)) |
| CSSStyleSetNext(style,DFHashTableLookup(repls,nextSelector)); |
| free(nextSelector); |
| } |
| free(allSelectors); |
| } |
| |
| void CSSEnsureUnique(CSSSheet *styleSheet, DFDocument *htmlDoc, int creating) |
| { |
| DFHashTable *repls = DFHashTableNew((DFCopyFunction)xstrdup,free); |
| determineReplacements(styleSheet,repls); |
| replaceSelectorsInSheet(repls,styleSheet); |
| replaceSelectorsInNode(repls,htmlDoc->root); |
| setMissingDisplayNames(styleSheet); |
| setParentForHeadings(styleSheet,repls); |
| DFHashTableRelease(repls); |
| } |
