| // 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 "CSS.h" |
| #include "CSSParser.h" |
| #include "CSSProperties.h" |
| #include "CSSSyntax.h" |
| #include "CSSSelector.h" |
| #include "DFBuffer.h" |
| #include "DFString.h" |
| #include "DFCharacterSet.h" |
| #include "DFCommon.h" |
| #include "DFPlatform.h" |
| #include <assert.h> |
| #include <ctype.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| typedef struct { |
| char *left; |
| char *right; |
| char *top; |
| char *bottom; |
| } SideValues; |
| |
| SideValues SideValuesEmpty = { NULL, NULL, NULL, NULL }; |
| |
| static void SideValuesClear(SideValues *values) |
| { |
| free(values->left); |
| free(values->right); |
| free(values->top); |
| free(values->bottom); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // // |
| // ContentPart // |
| // // |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| const char *ContentPartTypeString(ContentPartType type) |
| { |
| switch (type) { |
| case ContentPartNormal: |
| return "Normal"; |
| case ContentPartNone: |
| return "None"; |
| case ContentPartString: |
| return "String"; |
| case ContentPartURI: |
| return "URI"; |
| case ContentPartCounter: |
| return "Counter"; |
| case ContentPartCounters: |
| return "Counters"; |
| case ContentPartAttr: |
| return "Attr"; |
| case ContentPartOpenQuote: |
| return "OpenQuote"; |
| case ContentPartCloseQuote: |
| return "CloseQuote"; |
| case ContentPartNoOpenQuote: |
| return "NoOpenQuote"; |
| case ContentPartNoCloseQuote: |
| return "NoCloseQuote"; |
| default: |
| return "?"; |
| } |
| } |
| |
| ContentPart *ContentPartNew(ContentPartType type, const char *value, const char *arg) |
| { |
| ContentPart *part = (ContentPart *)xcalloc(1,sizeof(ContentPart)); |
| part->retainCount = 1; |
| part->type = type; |
| part->value = DFStrDup(value); |
| part->arg = DFStrDup(arg); |
| return part; |
| } |
| |
| ContentPart *ContentPartRetain(ContentPart *part) |
| { |
| if (part != NULL) |
| part->retainCount++; |
| return part; |
| } |
| |
| void ContentPartRelease(ContentPart *part) |
| { |
| if ((part == NULL) || (--part->retainCount > 0)) |
| return; |
| |
| free(part->value); |
| free(part->arg); |
| free(part); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // // |
| // ListStyleType // |
| // // |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| const char *ListStyleTypeString(ListStyleType type) |
| { |
| switch (type) { |
| case ListStyleTypeDisc: |
| return "disc"; |
| case ListStyleTypeCircle: |
| return "circle"; |
| case ListStyleTypeSquare: |
| return "square"; |
| case ListStyleTypeDecimal: |
| return "decimal"; |
| case ListStyleTypeDecimalLeadingZero: |
| return "decimal-leading-zero"; |
| case ListStyleTypeLowerRoman: |
| return "lower-roman"; |
| case ListStyleTypeUpperRoman: |
| return "upper-roman"; |
| case ListStyleTypeLowerGreek: |
| return "lower-greek"; |
| case ListStyleTypeLowerLatin: |
| return "lower-latin"; |
| case ListStyleTypeUpperLatin: |
| return "upper-latin"; |
| case ListStyleTypeArmenian: |
| return "armenian"; |
| case ListStyleTypeGeorgian: |
| return "georgian"; |
| case ListStyleTypeLowerAlpha: |
| return "lower-alpha"; |
| case ListStyleTypeUpperAlpha: |
| return "upper-alpha"; |
| case ListStyleTypeNone: |
| default: |
| return "none"; |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // // |
| // CSS // |
| // // |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| DFHashTable *CSSParseProperties(const char *input) |
| { |
| CSSParser *parser = CSSParserNew(input); |
| DFHashTable *properties = CSSParserProperties(parser); |
| CSSParserFree(parser); |
| if (properties == NULL) |
| return DFHashTableNew((DFCopyFunction)xstrdup,(DFFreeFunction)free); |
| else |
| return properties; |
| } |
| |
| char *CSSSerializeProperties(DFHashTable *cssProperties) |
| { |
| // Note: The properties *must* be sorted, because ODFAutomaticStyles relies on the resulting |
| // CSS text as a key into a hash table for anonymous styles |
| DFBuffer *output = DFBufferNew(); |
| size_t count = 0; |
| const char **allKeys = DFHashTableCopyKeys(cssProperties); |
| DFSortStringsCaseInsensitive(allKeys); |
| for (int i = 0; allKeys[i]; i++) { |
| const char *property = allKeys[i]; |
| if (DFStringHasPrefix(property,"-word") || DFStringHasPrefix(property,"-odf")) |
| continue; |
| const char *value = DFHashTableLookup(cssProperties,property); |
| if (count > 0) |
| DFBufferFormat(output,"; %s: %s",property,value); |
| else |
| DFBufferFormat(output,"%s: %s",property,value); |
| count++; |
| } |
| free(allKeys); |
| char *result = xstrdup(output->data); |
| DFBufferRelease(output); |
| return result; |
| } |
| |
| static void expandTextDecoration(DFHashTable *properties) |
| { |
| const char *value = DFHashTableLookup(properties,"text-decoration"); |
| if (value != NULL) { |
| char *textDecoration = DFLowerCase(value); |
| const char **tokens = DFStringTokenize(textDecoration,isspace); |
| for (int i = 0; tokens[i]; i++) { |
| if (!strcmp(tokens[i],"underline")) |
| DFHashTableAdd(properties,"text-decoration-underline","underline"); |
| if (!strcmp(tokens[i],"overline")) |
| DFHashTableAdd(properties,"text-decoration-overline","overline"); |
| if (!strcmp(tokens[i],"line-through")) |
| DFHashTableAdd(properties,"text-decoration-line-through","line-through"); |
| } |
| DFHashTableRemove(properties,"text-decoration"); |
| free(tokens); |
| free(textDecoration); |
| } |
| } |
| |
| static int splitSides(const char *shorthand, SideValues *sides) |
| { |
| const char **tokens = DFStringTokenize(shorthand,isspace); |
| int ok = 0; |
| int count = 0; |
| for (int i = 0; tokens[i]; i++) |
| count++; |
| switch (count) { |
| case 1: |
| sides->top = xstrdup(tokens[0]); |
| sides->bottom = xstrdup(tokens[0]); |
| sides->left = xstrdup(tokens[0]); |
| sides->right = xstrdup(tokens[0]); |
| ok = 1; |
| break; |
| case 2: |
| sides->top = xstrdup(tokens[0]); |
| sides->bottom = xstrdup(tokens[0]); |
| sides->left = xstrdup(tokens[1]); |
| sides->right = xstrdup(tokens[1]); |
| ok = 1; |
| break; |
| case 3: |
| sides->top = xstrdup(tokens[0]); |
| sides->left = xstrdup(tokens[1]); |
| sides->right = xstrdup(tokens[1]); |
| sides->bottom = xstrdup(tokens[2]); |
| ok = 1; |
| break; |
| case 4: |
| sides->top = xstrdup(tokens[0]); |
| sides->right = xstrdup(tokens[1]); |
| sides->bottom = xstrdup(tokens[2]); |
| sides->left = xstrdup(tokens[3]); |
| ok = 1; |
| break; |
| } |
| free(tokens); |
| return ok; |
| } |
| |
| static void expandBorderSide(const char *prefix, DFHashTable *properties) |
| { |
| const char *shorthand = DFHashTableLookup(properties,prefix); |
| if (shorthand != NULL) { |
| const char **tokens = DFStringTokenize(shorthand,isspace); |
| for (int i = 0; tokens[i]; i++) { |
| char *name = NULL; |
| if (CSSValueIsBorderStyle(tokens[i])) |
| name = DFFormatString("%s-style",prefix); |
| else if (CSSValueIsBorderWidth(tokens[i])) |
| name = DFFormatString("%s-width",prefix); |
| else if (CSSValueIsBorderColor(tokens[i])) |
| name = DFFormatString("%s-color",prefix); |
| if (name != NULL) |
| DFHashTableAdd(properties,name,tokens[i]); |
| free(name); |
| } |
| free(tokens); |
| DFHashTableRemove(properties,prefix); |
| } |
| } |
| |
| static void expandBorderAspect(const char *aspect, DFHashTable *properties) |
| { |
| char *propertyName = DFFormatString("border-%s",aspect); |
| const char *shorthand = DFHashTableLookup(properties,propertyName); |
| if (shorthand != NULL) { |
| SideValues sides = SideValuesEmpty; |
| if (splitSides(shorthand,&sides)) { |
| char *leftName = DFFormatString("border-left-%s",aspect); |
| char *rightName = DFFormatString("border-right-%s",aspect); |
| char *topName = DFFormatString("border-top-%s",aspect); |
| char *bottomName = DFFormatString("border-bottom-%s",aspect); |
| DFHashTableAdd(properties,leftName,sides.left); |
| DFHashTableAdd(properties,rightName,sides.right); |
| DFHashTableAdd(properties,topName,sides.top); |
| DFHashTableAdd(properties,bottomName,sides.bottom); |
| free(leftName); |
| free(rightName); |
| free(topName); |
| free(bottomName); |
| } |
| DFHashTableRemove(properties,propertyName); |
| SideValuesClear(&sides); |
| } |
| free(propertyName); |
| } |
| |
| static void expandBorders(DFHashTable *properties) |
| { |
| expandBorderSide("border-left",properties); |
| expandBorderSide("border-right",properties); |
| expandBorderSide("border-top",properties); |
| expandBorderSide("border-bottom",properties); |
| |
| expandBorderAspect("width",properties); |
| expandBorderAspect("color",properties); |
| expandBorderAspect("style",properties); |
| |
| // border |
| |
| const char *border = DFHashTableLookup(properties,"border"); |
| if (border != NULL) { |
| const char **tokens = DFStringTokenize(border,isspace); |
| for (int i = 0; tokens[i]; i++) { |
| const char *token = tokens[i]; |
| if (CSSValueIsBorderStyle(token)) { |
| DFHashTableAdd(properties,"border-left-style",token); |
| DFHashTableAdd(properties,"border-right-style",token); |
| DFHashTableAdd(properties,"border-top-style",token); |
| DFHashTableAdd(properties,"border-bottom-style",token); |
| } |
| else if (CSSValueIsBorderWidth(token)) { |
| DFHashTableAdd(properties,"border-left-width",token); |
| DFHashTableAdd(properties,"border-right-width",token); |
| DFHashTableAdd(properties,"border-top-width",token); |
| DFHashTableAdd(properties,"border-bottom-width",token); |
| } |
| else if (CSSValueIsBorderColor(token)) { |
| DFHashTableAdd(properties,"border-left-color",token); |
| DFHashTableAdd(properties,"border-right-color",token); |
| DFHashTableAdd(properties,"border-top-color",token); |
| DFHashTableAdd(properties,"border-bottom-color",token); |
| } |
| } |
| free(tokens); |
| DFHashTableRemove(properties,"border"); |
| } |
| |
| // border-radius |
| |
| const char *radius = DFHashTableLookup(properties,"border-radius"); |
| if (radius != NULL) { |
| DFHashTableAdd(properties,"border-top-left-radius",radius); |
| DFHashTableAdd(properties,"border-top-right-radius",radius); |
| DFHashTableAdd(properties,"border-bottom-left-radius",radius); |
| DFHashTableAdd(properties,"border-bottom-right-radius",radius); |
| DFHashTableRemove(properties,"border-radius"); |
| } |
| } |
| |
| static void expandPadding(DFHashTable *properties) |
| { |
| const char *shorthand = DFHashTableLookup(properties,"padding"); |
| if (shorthand != NULL) { |
| SideValues sides = SideValuesEmpty; |
| if (splitSides(shorthand,&sides)) { |
| DFHashTableAdd(properties,"padding-left",sides.left); |
| DFHashTableAdd(properties,"padding-right",sides.right); |
| DFHashTableAdd(properties,"padding-top",sides.top); |
| DFHashTableAdd(properties,"padding-bottom",sides.bottom); |
| } |
| DFHashTableRemove(properties,"padding"); |
| SideValuesClear(&sides); |
| } |
| } |
| |
| static void expandMargins(DFHashTable *properties) |
| { |
| const char *shorthand = DFHashTableLookup(properties,"margin"); |
| if (shorthand != NULL) { |
| SideValues sides = SideValuesEmpty; |
| if (splitSides(shorthand,&sides)) { |
| DFHashTableAdd(properties,"margin-left",sides.left); |
| DFHashTableAdd(properties,"margin-right",sides.right); |
| DFHashTableAdd(properties,"margin-top",sides.top); |
| DFHashTableAdd(properties,"margin-bottom",sides.bottom); |
| } |
| DFHashTableRemove(properties,"margin"); |
| SideValuesClear(&sides); |
| } |
| } |
| |
| void CSSExpandProperties(DFHashTable *properties) |
| { |
| expandTextDecoration(properties); |
| expandBorders(properties); |
| expandPadding(properties); |
| expandMargins(properties); |
| } |
| |
| DFHashTable *CSSCollapseProperties(CSSProperties *expanded) |
| { |
| DFHashTable *collapsed = DFHashTableCopy(expanded->hashTable); |
| const char *underline = DFHashTableLookup(collapsed,"text-decoration-underline"); |
| const char *overline = DFHashTableLookup(collapsed,"text-decoration-overline"); |
| const char *lineThrough = DFHashTableLookup(collapsed,"text-decoration-line-through"); |
| if ((underline != NULL) || (overline != NULL) || (lineThrough != NULL)) { |
| DFBuffer *buffer = DFBufferNew(); |
| if (underline != NULL) |
| DFBufferAppendString(buffer," underline"); |
| if (overline != NULL) |
| DFBufferAppendString(buffer," overline"); |
| if (lineThrough != NULL) |
| DFBufferAppendString(buffer," line-through"); |
| char *trimmed = DFStringTrimWhitespace(buffer->data); |
| DFHashTableAdd(collapsed,"text-decoration",trimmed); |
| DFHashTableRemove(collapsed,"text-decoration-underline"); |
| DFHashTableRemove(collapsed,"text-decoration-overline"); |
| DFHashTableRemove(collapsed,"text-decoration-line-through"); |
| free(trimmed); |
| DFBufferRelease(buffer); |
| } |
| |
| // Margins |
| |
| const char *marginLeft = CSSGet(expanded,"margin-left"); |
| const char *marginRight = CSSGet(expanded,"margin-right"); |
| const char *marginTop = CSSGet(expanded,"margin-top"); |
| const char *marginBottom = CSSGet(expanded,"margin-bottom"); |
| if ((marginLeft != NULL) && (marginRight != NULL) && (marginTop != NULL) && (marginBottom != NULL) && |
| DFStringEquals(marginLeft,marginRight) && |
| DFStringEquals(marginLeft,marginTop) && |
| DFStringEquals(marginLeft,marginBottom)) { |
| |
| DFHashTableAdd(collapsed,"margin",marginLeft); |
| DFHashTableRemove(collapsed,"margin-left"); |
| DFHashTableRemove(collapsed,"margin-right"); |
| DFHashTableRemove(collapsed,"margin-top"); |
| DFHashTableRemove(collapsed,"margin-bottom"); |
| } |
| |
| // Padding |
| |
| const char *paddingLeft = CSSGet(expanded,"padding-left"); |
| const char *paddingRight = CSSGet(expanded,"padding-right"); |
| const char *paddingTop = CSSGet(expanded,"padding-top"); |
| const char *paddingBottom = CSSGet(expanded,"padding-bottom"); |
| |
| if ((paddingLeft != NULL) && (paddingRight != NULL) && (paddingTop != NULL) && (paddingBottom != NULL) && |
| DFStringEquals(paddingLeft,paddingRight) && |
| DFStringEquals(paddingLeft,paddingTop) && |
| DFStringEquals(paddingLeft,paddingBottom)) { |
| |
| DFHashTableAdd(collapsed,"padding",paddingLeft); |
| DFHashTableRemove(collapsed,"padding-left"); |
| DFHashTableRemove(collapsed,"padding-right"); |
| DFHashTableRemove(collapsed,"padding-top"); |
| DFHashTableRemove(collapsed,"padding-bottom"); |
| } |
| |
| // Border radius |
| |
| const char *borderTopLeftRadius = CSSGet(expanded,"border-top-left-radius"); |
| const char *borderTopRightRadius = CSSGet(expanded,"border-top-right-radius"); |
| const char *borderBottomLeftRadius = CSSGet(expanded,"border-bottom-left-radius"); |
| const char *borderBottomRightRadius = CSSGet(expanded,"border-bottom-right-radius"); |
| |
| if ((borderTopLeftRadius != NULL) && (borderTopRightRadius != NULL) && |
| (borderBottomLeftRadius != NULL) && (borderBottomRightRadius != NULL) && |
| DFStringEquals(borderTopLeftRadius,borderTopRightRadius) && |
| DFStringEquals(borderTopLeftRadius,borderBottomLeftRadius) && |
| DFStringEquals(borderTopLeftRadius,borderBottomRightRadius)) { |
| |
| DFHashTableAdd(collapsed,"border-radius",borderTopLeftRadius); |
| DFHashTableRemove(collapsed,"border-top-left-radius"); |
| DFHashTableRemove(collapsed,"border-top-right-radius"); |
| DFHashTableRemove(collapsed,"border-bottom-left-radius"); |
| DFHashTableRemove(collapsed,"border-bottom-right-radius"); |
| } |
| |
| // Borders |
| |
| DFBuffer *borderLeft = DFBufferNew(); |
| DFBuffer *borderRight = DFBufferNew(); |
| DFBuffer *borderTop = DFBufferNew(); |
| DFBuffer *borderBottom = DFBufferNew(); |
| |
| const char *borderLeftWidth = CSSGet(expanded,"border-left-width"); |
| const char *borderRightWidth = CSSGet(expanded,"border-right-width"); |
| const char *borderTopWidth = CSSGet(expanded,"border-top-width"); |
| const char *borderBottomWidth = CSSGet(expanded,"border-bottom-width"); |
| |
| const char *borderLeftStyle = CSSGet(expanded,"border-left-style"); |
| const char *borderRightStyle = CSSGet(expanded,"border-right-style"); |
| const char *borderTopStyle = CSSGet(expanded,"border-top-style"); |
| const char *borderBottomStyle = CSSGet(expanded,"border-bottom-style"); |
| |
| const char *borderLeftColor = CSSGet(expanded,"border-left-color"); |
| const char *borderRightColor = CSSGet(expanded,"border-right-color"); |
| const char *borderTopColor = CSSGet(expanded,"border-top-color"); |
| const char *borderBottomColor = CSSGet(expanded,"border-bottom-color"); |
| |
| if (borderLeftWidth != NULL) |
| DFBufferFormat(borderLeft," %s",borderLeftWidth); |
| if (borderRightWidth != NULL) |
| DFBufferFormat(borderRight," %s",borderRightWidth); |
| if (borderTopWidth != NULL) |
| DFBufferFormat(borderTop," %s",borderTopWidth); |
| if (borderBottomWidth != NULL) |
| DFBufferFormat(borderBottom," %s",borderBottomWidth); |
| |
| if (borderLeftStyle != NULL) |
| DFBufferFormat(borderLeft," %s",borderLeftStyle); |
| if (borderRightStyle != NULL) |
| DFBufferFormat(borderRight," %s",borderRightStyle); |
| if (borderTopStyle != NULL) |
| DFBufferFormat(borderTop," %s",borderTopStyle); |
| if (borderBottomStyle != NULL) |
| DFBufferFormat(borderBottom," %s",borderBottomStyle); |
| |
| if (borderLeftColor != NULL) |
| DFBufferFormat(borderLeft," %s",borderLeftColor); |
| if (borderRightColor != NULL) |
| DFBufferFormat(borderRight," %s",borderRightColor); |
| if (borderTopColor != NULL) |
| DFBufferFormat(borderTop," %s",borderTopColor); |
| if (borderBottomColor != NULL) |
| DFBufferFormat(borderBottom," %s",borderBottomColor); |
| |
| if ((borderLeft->len > 0) && |
| !strcmp(borderLeft->data,borderRight->data) && |
| !strcmp(borderLeft->data,borderTop->data) && |
| !strcmp(borderLeft->data,borderBottom->data)) { |
| DFHashTableAdd(collapsed,"border",&borderLeft->data[1]); |
| } |
| else { |
| if (borderLeft->len > 0) |
| DFHashTableAdd(collapsed,"border-left",&borderLeft->data[1]); |
| if (borderRight->len > 0) |
| DFHashTableAdd(collapsed,"border-right",&borderRight->data[1]); |
| if (borderTop->len > 0) |
| DFHashTableAdd(collapsed,"border-top",&borderTop->data[1]); |
| if (borderBottom->len > 0) |
| DFHashTableAdd(collapsed,"border-bottom",&borderBottom->data[1]); |
| } |
| |
| DFHashTableRemove(collapsed,"border-left-width"); |
| DFHashTableRemove(collapsed,"border-right-width"); |
| DFHashTableRemove(collapsed,"border-top-width"); |
| DFHashTableRemove(collapsed,"border-bottom-width"); |
| |
| DFHashTableRemove(collapsed,"border-left-style"); |
| DFHashTableRemove(collapsed,"border-right-style"); |
| DFHashTableRemove(collapsed,"border-top-style"); |
| DFHashTableRemove(collapsed,"border-bottom-style"); |
| |
| DFHashTableRemove(collapsed,"border-left-color"); |
| DFHashTableRemove(collapsed,"border-right-color"); |
| DFHashTableRemove(collapsed,"border-top-color"); |
| DFHashTableRemove(collapsed,"border-bottom-color"); |
| |
| DFBufferRelease(borderLeft); |
| DFBufferRelease(borderRight); |
| DFBufferRelease(borderTop); |
| DFBufferRelease(borderBottom); |
| |
| return collapsed; |
| } |
| |
| DFArray *CSSParseContent(const char *content) |
| { |
| CSSParser *parser = CSSParserNew(content); |
| DFArray *result = CSSParserContent(parser); |
| CSSParserFree(parser); |
| return result; |
| } |
| |
| // Converts a string(selector) -> hashtable(properties) dictionary to a |
| // string(selector) -> string(propertyText) |
| |
| static DFHashTable *builtTextRules(DFHashTable *input) |
| { |
| DFHashTable *result = DFHashTableNew((DFCopyFunction)xstrdup,(DFFreeFunction)free); |
| |
| const char **allSelectors = DFHashTableCopyKeys(input); |
| for (int selIndex = 0; allSelectors[selIndex]; selIndex++) { |
| const char *selector = allSelectors[selIndex]; |
| |
| DFBuffer *text = DFBufferNew(); |
| |
| DFHashTable *cssProperties = DFHashTableLookup(input,selector); |
| assert(cssProperties != NULL); |
| |
| const char **allNames = DFHashTableCopyKeys(cssProperties); |
| DFSortStringsCaseInsensitive(allNames); |
| for (int nameIndex = 0; allNames[nameIndex]; nameIndex++) { |
| const char *name = allNames[nameIndex]; |
| const char *value = DFHashTableLookup(cssProperties,name); |
| DFBufferFormat(text," %s: %s;\n",name,value); |
| } |
| free(allNames); |
| |
| DFHashTableAdd(result,selector,text->data); |
| DFBufferRelease(text); |
| } |
| free(allSelectors); |
| return result; |
| } |
| |
| // Collates multiple rules with the same text into a single rule |
| // For example: |
| // .foo { color: blue; } |
| // .bar { color: blue; } |
| // becomes: |
| // .bar, .foo { color: blue; } |
| |
| static DFHashTable *combineTextRules(DFHashTable *separate) |
| { |
| DFHashTable *reverse = DFHashTableNew((DFCopyFunction)DFArrayRetain,(DFFreeFunction)DFArrayRelease); |
| |
| const char **separateKeys = DFHashTableCopyKeys(separate); |
| for (int i = 0; separateKeys[i]; i++) { |
| const char *selector = separateKeys[i]; |
| const char *text = DFHashTableLookup(separate,selector); |
| |
| DFArray *array = DFHashTableLookup(reverse,text); |
| if (array == NULL) { |
| array = DFArrayNew((DFCopyFunction)xstrdup,free); |
| DFHashTableAdd(reverse,text,array); |
| DFArrayRelease(array); |
| } |
| DFArrayAppend(array,(void *)selector); |
| } |
| free(separateKeys); |
| |
| DFHashTable *combined = DFHashTableNew((DFCopyFunction)xstrdup,(DFFreeFunction)free); |
| const char **reverseKeys = DFHashTableCopyKeys(reverse); |
| for (int keyIndex = 0; reverseKeys[keyIndex]; keyIndex++) { |
| const char *text = reverseKeys[keyIndex]; |
| DFArray *array = DFHashTableLookup(reverse,text); |
| const char **selectors = DFStringArrayFlatten(array); |
| DFSortStringsCaseInsensitive(selectors); |
| DFBuffer *combinedSelector = DFBufferNew(); |
| for (int i = 0; selectors[i]; i++) { |
| if (i > 0) |
| DFBufferFormat(combinedSelector,", "); |
| DFBufferFormat(combinedSelector,"%s",selectors[i]); |
| } |
| DFHashTableAdd(combined,combinedSelector->data,text); |
| DFBufferRelease(combinedSelector); |
| free(selectors); |
| } |
| free(reverseKeys); |
| |
| DFHashTableRelease(reverse); |
| return combined; |
| } |
| |
| char *CSSCopyStylesheetTextFromRules(DFHashTable *rules) |
| { |
| DFBuffer *output = DFBufferNew(); |
| DFHashTable *separate = builtTextRules(rules); |
| DFHashTable *textRules = combineTextRules(separate); |
| |
| const char **allSelectors = DFHashTableCopyKeys(textRules); |
| DFSortStringsCaseInsensitive(allSelectors); |
| for (int i = 0; allSelectors[i]; i++) { |
| const char *selector = allSelectors[i]; |
| if (i > 0) |
| DFBufferFormat(output,"\n");; |
| const char *text = DFHashTableLookup(textRules,selector); |
| assert(text != NULL); |
| DFBufferFormat(output,"%s {\n%s}\n",selector,text); |
| } |
| free(allSelectors); |
| DFHashTableRelease(separate); |
| DFHashTableRelease(textRules); |
| char *result = xstrdup(output->data); |
| DFBufferRelease(output); |
| return result; |
| } |
| |
| static int rgbValue(const char *untrimmed) |
| { |
| char *str = DFStringTrimWhitespace(untrimmed); |
| double d; |
| if (DFStringHasSuffix(str,"%")) // FIXME: Not covered by tests |
| d = atof(str)/100.0; |
| else |
| d = atof(str)/255.0; |
| |
| int i = (int)(d*255); |
| if (i < 0) |
| i = 0; |
| if (i > 255) |
| i = 255; |
| free(str); |
| return i; |
| } |
| |
| int parseRGB(const char *input, int *r, int *g, int *b) |
| { |
| size_t len = strlen(input); |
| |
| if (!DFStringHasPrefix(input,"rgb(")) |
| return 0; |
| |
| if (!DFStringHasSuffix(input,")")) |
| return 0; |
| |
| char *argtext = DFSubstring(input,4,len-1); |
| const char **args = DFStringSplit(argtext,",",0); |
| int ok = 0; |
| if (DFStringArrayCount(args) == 3) { |
| *r = rgbValue(args[0]); |
| *g = rgbValue(args[1]); |
| *b = rgbValue(args[2]); |
| ok = 1; |
| } |
| free(argtext); |
| free(args); |
| |
| return ok; |
| } |
| |
| static struct { |
| const char *name; |
| const char *hex; |
| } cssColorNames[] = { |
| {"maroon", "#800000"}, |
| {"red", "#ff0000"}, |
| {"orange", "#ffA500"}, |
| {"yellow", "#ffff00"}, |
| {"olive", "#808000"}, |
| {"purple", "#800080"}, |
| {"fuchsia", "#ff00ff"}, |
| {"white", "#ffffff"}, |
| {"lime", "#00ff00"}, |
| {"green", "#008000"}, |
| {"navy", "#000080"}, |
| {"blue", "#0000ff"}, |
| {"aqua", "#00ffff"}, |
| {"teal", "#008080"}, |
| {"black", "#000000"}, |
| {"silver", "#c0c0c0"}, |
| {"gray", "#808080"}, |
| {NULL, NULL} |
| }; |
| |
| char *CSSHexColor(const char *color, int includeHash) |
| { |
| if (color == NULL) |
| return NULL; |
| |
| char *result = NULL; |
| |
| // color: #f00 |
| if ((strlen(color) == 4) && (color[0] == '#')) { |
| // FIXME: Not covered by tests |
| char *upper = DFUpperCase(color); |
| char r = upper[1]; |
| char g = upper[2]; |
| char b = upper[3]; |
| result = DFFormatString("#%c%c%c%c%c%c",r,r,g,g,b,b); |
| free(upper); |
| } |
| // color: #ff0000 |
| else if ((strlen(color) == 7) && (color[0] == '#')) { |
| result = DFUpperCase(color); |
| } |
| // color: rgb(255,0,0) |
| // color: rgb(100%, 0%, 0%) |
| else if (DFStringHasPrefix(color,"rgb(") && DFStringHasSuffix(color,")")) { |
| int r = 0, g = 0, b = 0; |
| if (parseRGB(color,&r,&g,&b)) |
| result = DFFormatString("#%02X%02X%02X",r,g,b); |
| } |
| // color: red |
| else { |
| for (int i = 0; cssColorNames[i].name != NULL; i++) { |
| if (DFStringEqualsCI(cssColorNames[i].name,color)) { |
| result = DFUpperCase(cssColorNames[i].hex); |
| break; |
| } |
| } |
| } |
| |
| if (!includeHash && (result != NULL)) { |
| char *nohash = xstrdup(&result[1]); |
| free(result); |
| result = nohash; |
| } |
| |
| return result; |
| } |
| |
| char *CSSEncodeFontFamily(const char *input) |
| { |
| if (input == NULL) |
| return NULL; |
| if (DFStringContainsWhitespace(input)) |
| return DFQuote(input); |
| else |
| return xstrdup(input); |
| } |
| |
| char *CSSDecodeFontFamily(const char *input) |
| { |
| if (input == NULL) |
| return NULL; |
| else |
| return DFUnquote(input); |
| } |
| |
| static const char *inlinePropertyNames[] = { |
| "font-weight", |
| "font-style", |
| "text-decoration-underline", |
| "text-decoration-line-through", |
| "text-decoration-vertical-align", |
| "color", |
| "font-size", |
| "font-family", |
| NULL, |
| }; |
| |
| int CSSIsInlineProperty(const char *name) |
| { |
| for (int i = 0; inlinePropertyNames[i]; i++) { |
| if (!strcmp(name,inlinePropertyNames[i])) |
| return 1; |
| } |
| return 0; |
| } |
| |
| PageSize CSSParsePageSize(const char *input) |
| { |
| PageSize result = PageSizeUnknown; |
| char *normalized = DFStringNormalizeWhitespace(input); |
| if (DFStringEqualsCI(normalized,"a4 portrait")) |
| result = PageSizeA4Portrait; |
| else if (DFStringEqualsCI(normalized,"a4 landscape")) |
| result = PageSizeA4Landscape; |
| else if (DFStringEqualsCI(normalized,"letter portrait")) |
| result = PageSizeLetterPortrait; |
| else if (DFStringEqualsCI(normalized,"letter landscape")) |
| result = PageSizeLetterLandscape; |
| free(normalized); |
| return result; |
| } |
| |
| static int isNMStart(uint32_t ch) |
| { |
| return ((ch == '_') || |
| ((ch >= 'a') && (ch <= 'z')) || |
| ((ch >= 'A') && (ch <= 'Z'))); |
| } |
| |
| static int isNMChar(uint32_t ch) |
| { |
| return ((ch == '_') || |
| ((ch >= 'a') && (ch <= 'z')) || |
| ((ch >= 'A') && (ch <= 'Z')) || |
| ((ch >= '0') && (ch <= '9')) || |
| (ch == '-')); |
| } |
| |
| static void appendUTF32Char(DFBuffer *buf, uint32_t ch) |
| { |
| DFBufferAppendData(buf,(const void *)&ch,sizeof(ch)); |
| } |
| |
| static unsigned int fromHexChar(uint32_t ch) |
| { |
| if ((ch >= '0') && (ch <= '9')) |
| return ch - '0'; |
| if ((ch >= 'a') && (ch <= 'f')) |
| return 10 + ch - 'a'; |
| if ((ch >= 'A') && (ch <= 'F')) |
| return 10 + ch - 'A'; |
| return 0; |
| } |
| |
| static void CSSEscapeIdentifier(const uint32_t *chars, size_t len, DFBuffer *output) |
| { |
| size_t pos = 0; |
| |
| if ((pos < len) && (chars[pos] == '-')) { |
| if (len == 1) { |
| appendUTF32Char(output,'\\'); |
| appendUTF32Char(output,'2'); |
| appendUTF32Char(output,'d'); |
| } |
| else { |
| appendUTF32Char(output,'-'); |
| } |
| pos++; |
| } |
| |
| size_t start = pos; |
| |
| while (pos < len) { |
| if ((pos == start) && isNMStart(chars[pos])) { |
| appendUTF32Char(output,chars[pos]); |
| pos++; |
| } |
| else if ((pos > start) && isNMChar(chars[pos])) { |
| appendUTF32Char(output,chars[pos]); |
| pos++; |
| } |
| else if (chars[pos] == 0) { |
| appendUTF32Char(output,'\\'); |
| appendUTF32Char(output,'0'); |
| appendUTF32Char(output,' '); |
| pos++; |
| } |
| else { |
| unsigned int value = chars[pos++]; |
| |
| appendUTF32Char(output,'\\'); |
| |
| uint32_t bytes[6]; |
| int byteCount = 0; |
| while ((value > 0) && (byteCount < 6)){ |
| unsigned int nibble = value & 0xF; |
| if (nibble >= 0xA) |
| bytes[5-byteCount] = 'a'+nibble-0xA; |
| else |
| bytes[5-byteCount] = '0'+nibble; |
| value >>= 4; |
| byteCount++; |
| } |
| DFBufferAppendData(output,(const void *)&bytes[6-byteCount],byteCount*sizeof(uint32_t)); |
| appendUTF32Char(output,' '); |
| } |
| } |
| |
| // Remove trailing spaces |
| size_t outLen = output->len/sizeof(uint32_t); |
| uint32_t *outChars = (uint32_t *)output->data; |
| while ((outLen > 0) && (outChars[outLen-1] == ' ')) { |
| output->len -= sizeof(uint32_t); |
| outLen--; |
| } |
| } |
| |
| static void CSSUnescapeIdentifier(const uint32_t *chars, size_t len, DFBuffer *output) |
| { |
| size_t pos = 0; |
| |
| if ((pos < len) && (chars[pos] == '-')) { |
| appendUTF32Char(output,'-'); |
| pos++; |
| } |
| |
| size_t start = pos; |
| |
| while (pos < len) { |
| if (chars[pos] == '\\') { |
| pos++; |
| |
| uint32_t value = 0; |
| int numDigits = 0; |
| while ((numDigits < 6) && (pos < len) && DFCharIsHex(chars[pos])) { |
| value = value*16 + fromHexChar(chars[pos]); |
| pos++; |
| numDigits++; |
| } |
| |
| appendUTF32Char(output,value); |
| |
| if (pos < len) { |
| switch (chars[pos]) { |
| case ' ': |
| case '\t': |
| case '\n': |
| case '\f': |
| pos++; |
| break; |
| case '\r': |
| if ((pos + 1 < len) && (chars[pos+1] == '\n')) |
| pos += 2; |
| else |
| pos++; |
| break; |
| } |
| } |
| } |
| else if ((pos == start) && isNMStart(chars[pos])) { |
| appendUTF32Char(output,chars[pos]); |
| pos++; |
| } |
| else if ((pos > start) && isNMChar(chars[pos])) { |
| appendUTF32Char(output,chars[pos]); |
| pos++; |
| } |
| else { |
| pos++; |
| } |
| } |
| } |
| |
| char *CSSEscapeIdent(const char *cunescaped) |
| { |
| if (cunescaped == NULL) |
| return NULL;; |
| |
| uint32_t *unescaped32 = DFUTF8To32(cunescaped); |
| size_t len32 = DFUTF32Length(unescaped32); |
| DFBuffer *output = DFBufferNew(); |
| |
| CSSEscapeIdentifier(unescaped32,len32,output); |
| appendUTF32Char(output,0); |
| assert((output->len % 4) == 0); |
| char *result = DFUTF32to8((const uint32_t *)output->data); |
| |
| free(unescaped32); |
| DFBufferRelease(output); |
| return result; |
| } |
| |
| char *CSSUnescapeIdent(const char *cescaped) |
| { |
| if (cescaped == NULL) |
| return NULL;; |
| |
| uint32_t *escaped32 = DFUTF8To32(cescaped); |
| size_t len32 = DFUTF32Length(escaped32); |
| DFBuffer *output = DFBufferNew(); |
| |
| CSSUnescapeIdentifier(escaped32,len32,output); |
| appendUTF32Char(output,0); |
| assert((output->len % 4) == 0); |
| char *result = DFUTF32to8((const uint32_t *)output->data); |
| |
| free(escaped32); |
| DFBufferRelease(output); |
| return result; |
| } |
| |
| void CSSParseSelector(const char *cinput, char **result, char **suffix) |
| { |
| size_t len = strlen(cinput); |
| size_t pos = 0; |
| |
| // Parse element name |
| while ((pos < len) && (cinput[pos] != '.') && (cinput[pos] != ' ') && (cinput[pos] != ':')) |
| pos++; |
| |
| char *elementName = DFSubstring(cinput,0,pos); |
| |
| // Parse class name |
| if ((pos < len) && (cinput[pos] == '.')) { |
| pos++; |
| size_t classStart = pos; |
| while (pos < len) { |
| if (cinput[pos] == '\\') { |
| pos++; |
| while ((pos < len) && DFCharIsHex(cinput[pos])) |
| pos++; |
| if ((pos < len) && (cinput[pos] == ' ')) |
| pos++; |
| } |
| else if ((cinput[pos] == ' ') || (cinput[pos] == ':')) { |
| break; |
| } |
| else { |
| pos++; |
| } |
| } |
| |
| char *className = DFSubstring(cinput,classStart,pos); |
| char *unescapedClassName = CSSUnescapeIdent(className); |
| *result = DFFormatString("%s.%s",elementName,unescapedClassName); |
| free(unescapedClassName); |
| free(className); |
| } |
| else { |
| *result = xstrdup(elementName); |
| } |
| |
| // Parse suffix |
| // FIXME: ignore spaces at start? |
| *suffix = xstrdup(&cinput[pos]); |
| |
| free(elementName); |
| } |
