DocFormats/filters/ooxml/src/word/formatting/WordNumPr.c - incubator-retired-corinthia - Git at Google

 // 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 "WordNumPr.h"
 #include "WordNumbering.h"
 #include "WordSheet.h"
 #include "CSS.h"
 #include "DFString.h"
 #include "DFCommon.h"
 #include <assert.h>
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>

 static char *parseLvlText(const char *input, WordConcreteNum *num)
 {
     DFBuffer *result = DFBufferNew();
     size_t len = strlen(input);
     size_t pos = 0;

     int endsWithWhitespace = 0;
     size_t start = 0;
     while (1) {
         if ((pos >= len) || (input[pos] == '%')) {
             if (pos > start) {
                 char *str = DFSubstring(input,start,pos);
                 if (result->len > 0)
                     DFBufferFormat(result," ");
                 char *quotedStr = DFQuote(str);
                 DFBufferFormat(result,"%s",quotedStr);
                 free(quotedStr);
                 endsWithWhitespace = (strlen(str) > 0) && isspace(str[strlen(str)-1]);
                 free(str);
             }
             start = pos;
         }
         if (pos >= len)
             break;
         if ((input[pos] == '%') && (pos+1 < len) &&
             (input[pos+1] >= '1') && (input[pos+1] <= '6')) {
             int ilvl = input[pos+1] - '1';

             if (result->len > 0)
                 DFBufferFormat(result," ");
             char *counterName = DFFormatString("h%d",ilvl+1);

             WordNumLevel *numLevel = WordConcreteNumGetLevel(num,ilvl);
             const char *type = (numLevel != NULL) ? WordNumLevelToListStyleType(numLevel) : NULL;
             if ((type != NULL) && !DFStringEquals(type,"decimal"))
                 DFBufferFormat(result,"counter(%s,%s)",counterName,type);
             else
                 DFBufferFormat(result,"counter(%s)",counterName);
             free(counterName);
             endsWithWhitespace = 0;

             pos += 2;
             start = pos;
         }
         else {
             pos++;
         }
     }

     if ((result->len > 0) && !endsWithWhitespace)
         DFBufferFormat(result," \" \"");
     char *str = xstrdup(result->data);
     DFBufferRelease(result);
     return str;
 }

 void WordGetNumPrStyle(DFNode *numPr, CSSStyle *style, WordConverter *converter)
 {
     DFNode *ilvlElem = DFChildWithTag(numPr,WORD_ILVL);
     DFNode *numIdElem = DFChildWithTag(numPr,WORD_NUMID);
     const char *ilvlStr = (ilvlElem != NULL) ? DFGetAttribute(ilvlElem,WORD_VAL) : NULL;
     const char *numIdStr = (numIdElem != NULL) ? DFGetAttribute(numIdElem,WORD_VAL) : NULL;
     if (numIdStr == NULL)
         return;

     int ilvl = (ilvlStr != NULL) ? atoi(ilvlStr) : 0;
     WordConcreteNum *num = WordNumberingConcreteWithId(converter->numbering,numIdStr);
     if (num == NULL) {
         return;
     }

     CSSProperties *before = CSSStyleBefore(style);
     CSSProperties *during = CSSStyleRule(style);

     WordNumLevel *level = WordConcreteNumGetLevel(num,ilvl);
     if ((level != NULL) && (level->lvlText != NULL)) {
         char *parsed = parseLvlText(level->lvlText,num);
         CSSPut(before,"content",parsed);
         free(parsed);
     }

     char *mainCounterName = DFFormatString("h%d",ilvl+1);
     CSSPut(during,"counter-increment",mainCounterName);
     free(mainCounterName);

     DFBuffer *reset = DFBufferNew();
     for (int i = ilvl+1; i <= 5; i++) {
         char *counterName = DFFormatString("h%d",i+1);
         if (i == ilvl+1)
             DFBufferFormat(reset,"%s",counterName);
         else
             DFBufferFormat(reset," %s",counterName);
         free(counterName);
     }
     CSSPut(during,"counter-reset",reset->data);
     DFBufferRelease(reset);
 }

 typedef struct WordNumInfo WordNumInfo;

 struct WordNumInfo {
     char *cssType; // Value range: CSS list-style-type
     char *cssLvlText; // Values: Word's lvlText format
     char *wordNumId;
     char *wordIlvl;
     WordNumLevel *wordLevel;
 };

 static WordNumInfo *WordNumInfoNew(void)
 {
     return (WordNumInfo *)xcalloc(1,sizeof(WordNumInfo));
 }

 static void WordNumInfoFree(WordNumInfo *info)
 {
     free(info->cssType);
     free(info->cssLvlText);
     free(info->wordNumId);
     free(info->wordIlvl);
     free(info);
 }

 void updateNumbering(WordConverter *converter, CSSSheet *cssSheet)
 {
     DFHashTable *infoByStyleId = DFHashTableNew(NULL,(DFFreeFunction)WordNumInfoFree);
     WordSheet *wordSheet = converter->styles;

     int cssLevelNumbered[6];
     int wordLevelNumbered[6];
     for (int i = 1; i <= 6; i++) {
         cssLevelNumbered[i-1] = 0;
         wordLevelNumbered[i-1] = 0;
     }

     const char **cssSelectors = CSSSheetCopySelectors(cssSheet);
     for (int i = 0; cssSelectors[i]; i++) {
         const char *selector = cssSelectors[i];
         if (WordStyleFamilyForSelector(selector) != StyleFamilyParagraph)
             continue;

         WordNumInfo *info = WordNumInfoNew();
         DFHashTableAdd(infoByStyleId,selector,info);

         CSSStyle *cssStyle = CSSSheetLookupSelector(cssSheet,selector,0,0);
         if ((cssStyle != NULL) && (CSSGet(CSSStyleBefore(cssStyle),"content") != NULL)) {
             char *elementName = CSSSelectorCopyElementName(selector);

             if ((cssStyle->headingLevel >= 1) && (cssStyle->headingLevel <= 6))
                 cssLevelNumbered[cssStyle->headingLevel-1] = 1;;

             DFArray *contentParts = CSSParseContent(CSSGet(CSSStyleBefore(cssStyle),"content"));
             DFBuffer *format = DFBufferNew();
             for (size_t partIndex = 0; partIndex < DFArrayCount(contentParts); partIndex++) {
                 ContentPart *part = DFArrayItemAt(contentParts,partIndex);
                 if (part->type == ContentPartCounter) {
                     if (DFStringEquals(part->value,elementName)) {
                         free(info->cssType);
                         if (part->arg != NULL)
                             info->cssType = xstrdup(part->arg);
                         else
                             info->cssType = xstrdup("decimal");
                     }
                     if ((strlen(part->value) == 2) && (part->value[0] == 'h'))
                         DFBufferFormat(format,"%%%c",part->value[1]);
                 }
                 else if (part->type == ContentPartString) {
                     // FIXME: Need test case for string that actually contains %
                     char *noPercent = DFStringReplace(part->value,"%","");
                     DFBufferFormat(format,"%s",noPercent);
                     free(noPercent);
                 }
             }
             DFArrayRelease(contentParts);

             if ((format->len > 0) && isspace(format->data[format->len-1])) {
                 format->data[format->len-1] = '\0';
                 format->len--;
             }

             info->cssLvlText = xstrdup(format->data);
             free(elementName);
             DFBufferRelease(format);
         }

         WordStyle *wordStyle = WordSheetStyleForSelector(wordSheet,selector);
         if (wordStyle != NULL) {
             DFNode *pPr = DFChildWithTag(wordStyle->element,WORD_PPR);
             DFNode *numPr = DFChildWithTag(pPr,WORD_NUMPR);
             const char *numId = DFGetChildAttribute(numPr,WORD_NUMID,WORD_VAL);
             const char *ilvl = DFGetChildAttribute(numPr,WORD_ILVL,WORD_VAL);
             if (numId != NULL) {
                 if (ilvl == NULL)
                     ilvl = "0";;
                 WordConcreteNum *concreteNum = WordNumberingConcreteWithId(converter->numbering,numId);
                 if (concreteNum != NULL) {
                     WordNumLevel *level = WordConcreteNumGetLevel(concreteNum,atoi(ilvl));
                     if (level != NULL) {
                         info->wordNumId = xstrdup(numId);
                         info->wordIlvl = xstrdup(ilvl);
                         info->wordLevel = level;

                         int ilvlValue = atoi(ilvl);
                         if ((ilvlValue >= 0) && (ilvlValue <= 5))
                             wordLevelNumbered[ilvlValue] = 1;
                     }
                 }
             }
         }
     }
     free(cssSelectors);

     // For any CSS heading styles that are missing either a type or level text, clear the
     // corresponding word documents, so these are removed from styles.xml if they previously
     // existed.
     cssSelectors = DFHashTableCopyKeys(infoByStyleId);
     for (int i = 0; cssSelectors[i]; i++) {
         const char *selector = cssSelectors[i];
         WordNumInfo *info = DFHashTableLookup(infoByStyleId,selector);
         if ((info != NULL) && (info->cssLvlText == NULL)) {
             free(info->wordNumId);
             free(info->wordIlvl);
             info->wordLevel = NULL;
             info->wordNumId = NULL;
             info->wordIlvl = NULL;
         }
     }
     free(cssSelectors);

     int totalCSSNumbered = 0;
     int totalWordNumbered = 0;

     for (int i = 0; i <= 5; i++) {
         if (cssLevelNumbered[i])
             totalCSSNumbered++;
         if (wordLevelNumbered[i])
             totalWordNumbered++;
     }

     if ((totalCSSNumbered > 0) && (totalWordNumbered < 6)) {
         // We don't have all 6 heading levels. Recreate everything
         WordAbstractNum *abstractNum = WordNumberingCreateAbstractNum(converter->numbering);
         WordConcreteNum *concreteNum = WordNumberingAddConcreteWithAbstract(converter->numbering,abstractNum);
         char *prevType = NULL;
         char *prevLvlText = NULL;

         DFHashTable *selectorsByLevel = DFHashTableNew(NULL,NULL);
         const char **allSelectors = CSSSheetCopySelectors(cssSheet);
         for (int i = 0; allSelectors[i]; i++) {
             CSSStyle *style = CSSSheetLookupSelector(cssSheet,allSelectors[i],0,0);
             if ((style->headingLevel >= 1) && (style->headingLevel <= 6)) {
                 int level = style->headingLevel - 1;
                 SelectorList *item = (SelectorList *)xcalloc(1,sizeof(SelectorList));
                 item->selector = xstrdup(style->selector);
                 item->next = DFHashTableLookupInt(selectorsByLevel,level);
                 DFHashTableAddInt(selectorsByLevel,level,item);
             }
         }
         free(allSelectors);

         DFHashTable *numStylesByLevel = DFHashTableNew((DFCopyFunction)CSSStyleRetain,(DFFreeFunction)CSSStyleRelease);

         for (int i = 0; i < 6; i++) {
             SelectorList *list = DFHashTableLookupInt(selectorsByLevel,i);
             SelectorList *next;
             for (SelectorList *item = list; item != NULL; item = next) {
                 next = item->next;
                 CSSStyle *style = CSSSheetLookupSelector(cssSheet,item->selector,0,0);
                 // FIXME: need to do this comparison based on lvlText
                 if ((CSSGet(CSSStyleBefore(style),"content") != NULL) &&
                     !DFStringEquals(CSSGet(CSSStyleBefore(style),"content"),"none") &&
                     !DFStringEquals(CSSGet(CSSStyleBefore(style),"content"),"\"\"")) {
                     DFHashTableAddInt(numStylesByLevel,i,style);
                 }
                 free(item->selector);
                 free(item);
             }
         }

         for (int i = 0; i < 6; i++) {
             CSSStyle *style = DFHashTableLookupInt(numStylesByLevel,i);
             char *curType = NULL;
             char *curLvlText = NULL;
             WordNumInfo *info = NULL;


             if (style != NULL) {
                 info = DFHashTableLookup(infoByStyleId,style->selector);
                 if (info == NULL) {
                     info = WordNumInfoNew();
                     DFHashTableAdd(infoByStyleId,style->selector,info);
                 }
                 curType = xstrdup(info->cssType);
                 curLvlText = xstrdup(info->cssLvlText);
             }


             if (curType == NULL)
                 curType = (prevType != NULL) ? xstrdup(prevType) : xstrdup("decimal");

             if ((curLvlText == NULL) || (strlen(curLvlText) == 0)) {
                 free(curLvlText);
                 if ((prevLvlText == NULL) || (strlen(prevLvlText) == 0))
                     curLvlText = DFFormatString("%%%d",i+1);
                 else
                     curLvlText = DFFormatString("%s.%%%d",prevLvlText,i+1);
             }

             WordNumLevel *numLevel = WordNumberingCreateLevel(converter->numbering,curType,curLvlText,i,0);
             DFAppendChild(abstractNum->element,numLevel->element);
             WordAbstractNumAddLevel(abstractNum,numLevel);

             if (info != NULL) {
                 info->wordLevel = numLevel;
                 assert(info->wordLevel != NULL);
                 free(info->wordNumId);
                 free(info->wordIlvl);
                 info->wordNumId = xstrdup(concreteNum->numId);
                 info->wordIlvl = DFFormatString("%d",i);
             }

             free(prevType);
             free(prevLvlText);
             prevType = curType;
             prevLvlText = curLvlText;
         }
         free(prevType);
         free(prevLvlText);
         DFHashTableRelease(selectorsByLevel);
         DFHashTableRelease(numStylesByLevel);
     }

     cssSelectors = DFHashTableCopyKeys(infoByStyleId);
     for (int i = 0; cssSelectors[i]; i++) {
         const char *selector = cssSelectors[i];
         WordNumInfo *info = DFHashTableLookup(infoByStyleId,selector);
         CSSStyle *cssStyle = CSSSheetLookupSelector(cssSheet,selector,0,0);
         if (cssStyle != NULL) {
             CSSPut(CSSStyleRule(cssStyle),"-word-numId",info->wordNumId);
             if (DFStringEquals(info->wordIlvl,"0"))
                 CSSPut(CSSStyleRule(cssStyle),"-word-ilvl",NULL);
             else
                 CSSPut(CSSStyleRule(cssStyle),"-word-ilvl",info->wordIlvl);
         }
     }
     free(cssSelectors);
     DFHashTableRelease(infoByStyleId);
 }
	// 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 "WordNumPr.h"
	#include "WordNumbering.h"
	#include "WordSheet.h"
	#include "CSS.h"
	#include "DFString.h"
	#include "DFCommon.h"
	#include <assert.h>
	#include <ctype.h>
	#include <stdlib.h>
	#include <string.h>

	static char parseLvlText(const char input, WordConcreteNum *num)
	{
	DFBuffer *result = DFBufferNew();
	size_t len = strlen(input);
	size_t pos = 0;

	int endsWithWhitespace = 0;
	size_t start = 0;
	while (1) {
	if ((pos >= len) \|\| (input[pos] == '%')) {
	if (pos > start) {
	char *str = DFSubstring(input,start,pos);
	if (result->len > 0)
	DFBufferFormat(result," ");
	char *quotedStr = DFQuote(str);
	DFBufferFormat(result,"%s",quotedStr);
	free(quotedStr);
	endsWithWhitespace = (strlen(str) > 0) && isspace(str[strlen(str)-1]);
	free(str);
	}
	start = pos;
	}
	if (pos >= len)
	break;
	if ((input[pos] == '%') && (pos+1 < len) &&
	(input[pos+1] >= '1') && (input[pos+1] <= '6')) {
	int ilvl = input[pos+1] - '1';

	if (result->len > 0)
	DFBufferFormat(result," ");
	char *counterName = DFFormatString("h%d",ilvl+1);

	WordNumLevel *numLevel = WordConcreteNumGetLevel(num,ilvl);
	const char *type = (numLevel != NULL) ? WordNumLevelToListStyleType(numLevel) : NULL;
	if ((type != NULL) && !DFStringEquals(type,"decimal"))
	DFBufferFormat(result,"counter(%s,%s)",counterName,type);
	else
	DFBufferFormat(result,"counter(%s)",counterName);
	free(counterName);
	endsWithWhitespace = 0;

	pos += 2;
	start = pos;
	}
	else {
	pos++;
	}
	}

	if ((result->len > 0) && !endsWithWhitespace)
	DFBufferFormat(result," \" \"");
	char *str = xstrdup(result->data);
	DFBufferRelease(result);
	return str;
	}

	void WordGetNumPrStyle(DFNode numPr, CSSStyle style, WordConverter *converter)
	{
	DFNode *ilvlElem = DFChildWithTag(numPr,WORD_ILVL);
	DFNode *numIdElem = DFChildWithTag(numPr,WORD_NUMID);
	const char *ilvlStr = (ilvlElem != NULL) ? DFGetAttribute(ilvlElem,WORD_VAL) : NULL;
	const char *numIdStr = (numIdElem != NULL) ? DFGetAttribute(numIdElem,WORD_VAL) : NULL;
	if (numIdStr == NULL)
	return;

	int ilvl = (ilvlStr != NULL) ? atoi(ilvlStr) : 0;
	WordConcreteNum *num = WordNumberingConcreteWithId(converter->numbering,numIdStr);
	if (num == NULL) {
	return;
	}

	CSSProperties *before = CSSStyleBefore(style);
	CSSProperties *during = CSSStyleRule(style);

	WordNumLevel *level = WordConcreteNumGetLevel(num,ilvl);
	if ((level != NULL) && (level->lvlText != NULL)) {
	char *parsed = parseLvlText(level->lvlText,num);
	CSSPut(before,"content",parsed);
	free(parsed);
	}

	char *mainCounterName = DFFormatString("h%d",ilvl+1);
	CSSPut(during,"counter-increment",mainCounterName);
	free(mainCounterName);

	DFBuffer *reset = DFBufferNew();
	for (int i = ilvl+1; i <= 5; i++) {
	char *counterName = DFFormatString("h%d",i+1);
	if (i == ilvl+1)
	DFBufferFormat(reset,"%s",counterName);
	else
	DFBufferFormat(reset," %s",counterName);
	free(counterName);
	}
	CSSPut(during,"counter-reset",reset->data);
	DFBufferRelease(reset);
	}

	typedef struct WordNumInfo WordNumInfo;

	struct WordNumInfo {
	char *cssType; // Value range: CSS list-style-type
	char *cssLvlText; // Values: Word's lvlText format
	char *wordNumId;
	char *wordIlvl;
	WordNumLevel *wordLevel;
	};

	static WordNumInfo *WordNumInfoNew(void)
	{
	return (WordNumInfo *)xcalloc(1,sizeof(WordNumInfo));
	}

	static void WordNumInfoFree(WordNumInfo *info)
	{
	free(info->cssType);
	free(info->cssLvlText);
	free(info->wordNumId);
	free(info->wordIlvl);
	free(info);
	}

	void updateNumbering(WordConverter converter, CSSSheet cssSheet)
	{
	DFHashTable *infoByStyleId = DFHashTableNew(NULL,(DFFreeFunction)WordNumInfoFree);
	WordSheet *wordSheet = converter->styles;

	int cssLevelNumbered[6];
	int wordLevelNumbered[6];
	for (int i = 1; i <= 6; i++) {
	cssLevelNumbered[i-1] = 0;
	wordLevelNumbered[i-1] = 0;
	}

	const char **cssSelectors = CSSSheetCopySelectors(cssSheet);
	for (int i = 0; cssSelectors[i]; i++) {
	const char *selector = cssSelectors[i];
	if (WordStyleFamilyForSelector(selector) != StyleFamilyParagraph)
	continue;

	WordNumInfo *info = WordNumInfoNew();
	DFHashTableAdd(infoByStyleId,selector,info);

	CSSStyle *cssStyle = CSSSheetLookupSelector(cssSheet,selector,0,0);
	if ((cssStyle != NULL) && (CSSGet(CSSStyleBefore(cssStyle),"content") != NULL)) {
	char *elementName = CSSSelectorCopyElementName(selector);

	if ((cssStyle->headingLevel >= 1) && (cssStyle->headingLevel <= 6))
	cssLevelNumbered[cssStyle->headingLevel-1] = 1;;

	DFArray *contentParts = CSSParseContent(CSSGet(CSSStyleBefore(cssStyle),"content"));
	DFBuffer *format = DFBufferNew();
	for (size_t partIndex = 0; partIndex < DFArrayCount(contentParts); partIndex++) {
	ContentPart *part = DFArrayItemAt(contentParts,partIndex);
	if (part->type == ContentPartCounter) {
	if (DFStringEquals(part->value,elementName)) {
	free(info->cssType);
	if (part->arg != NULL)
	info->cssType = xstrdup(part->arg);
	else
	info->cssType = xstrdup("decimal");
	}
	if ((strlen(part->value) == 2) && (part->value[0] == 'h'))
	DFBufferFormat(format,"%%%c",part->value[1]);
	}
	else if (part->type == ContentPartString) {
	// FIXME: Need test case for string that actually contains %
	char *noPercent = DFStringReplace(part->value,"%","");
	DFBufferFormat(format,"%s",noPercent);
	free(noPercent);
	}
	}
	DFArrayRelease(contentParts);

	if ((format->len > 0) && isspace(format->data[format->len-1])) {
	format->data[format->len-1] = '\0';
	format->len--;
	}

	info->cssLvlText = xstrdup(format->data);
	free(elementName);
	DFBufferRelease(format);
	}

	WordStyle *wordStyle = WordSheetStyleForSelector(wordSheet,selector);
	if (wordStyle != NULL) {
	DFNode *pPr = DFChildWithTag(wordStyle->element,WORD_PPR);
	DFNode *numPr = DFChildWithTag(pPr,WORD_NUMPR);
	const char *numId = DFGetChildAttribute(numPr,WORD_NUMID,WORD_VAL);
	const char *ilvl = DFGetChildAttribute(numPr,WORD_ILVL,WORD_VAL);
	if (numId != NULL) {
	if (ilvl == NULL)
	ilvl = "0";;
	WordConcreteNum *concreteNum = WordNumberingConcreteWithId(converter->numbering,numId);
	if (concreteNum != NULL) {
	WordNumLevel *level = WordConcreteNumGetLevel(concreteNum,atoi(ilvl));
	if (level != NULL) {
	info->wordNumId = xstrdup(numId);
	info->wordIlvl = xstrdup(ilvl);
	info->wordLevel = level;

	int ilvlValue = atoi(ilvl);
	if ((ilvlValue >= 0) && (ilvlValue <= 5))
	wordLevelNumbered[ilvlValue] = 1;
	}
	}
	}
	}
	}
	free(cssSelectors);

	// For any CSS heading styles that are missing either a type or level text, clear the
	// corresponding word documents, so these are removed from styles.xml if they previously
	// existed.
	cssSelectors = DFHashTableCopyKeys(infoByStyleId);
	for (int i = 0; cssSelectors[i]; i++) {
	const char *selector = cssSelectors[i];
	WordNumInfo *info = DFHashTableLookup(infoByStyleId,selector);
	if ((info != NULL) && (info->cssLvlText == NULL)) {
	free(info->wordNumId);
	free(info->wordIlvl);
	info->wordLevel = NULL;
	info->wordNumId = NULL;
	info->wordIlvl = NULL;
	}
	}
	free(cssSelectors);

	int totalCSSNumbered = 0;
	int totalWordNumbered = 0;

	for (int i = 0; i <= 5; i++) {
	if (cssLevelNumbered[i])
	totalCSSNumbered++;
	if (wordLevelNumbered[i])
	totalWordNumbered++;
	}

	if ((totalCSSNumbered > 0) && (totalWordNumbered < 6)) {
	// We don't have all 6 heading levels. Recreate everything
	WordAbstractNum *abstractNum = WordNumberingCreateAbstractNum(converter->numbering);
	WordConcreteNum *concreteNum = WordNumberingAddConcreteWithAbstract(converter->numbering,abstractNum);
	char *prevType = NULL;
	char *prevLvlText = NULL;

	DFHashTable *selectorsByLevel = DFHashTableNew(NULL,NULL);
	const char **allSelectors = CSSSheetCopySelectors(cssSheet);
	for (int i = 0; allSelectors[i]; i++) {
	CSSStyle *style = CSSSheetLookupSelector(cssSheet,allSelectors[i],0,0);
	if ((style->headingLevel >= 1) && (style->headingLevel <= 6)) {
	int level = style->headingLevel - 1;
	SelectorList item = (SelectorList )xcalloc(1,sizeof(SelectorList));
	item->selector = xstrdup(style->selector);
	item->next = DFHashTableLookupInt(selectorsByLevel,level);
	DFHashTableAddInt(selectorsByLevel,level,item);
	}
	}
	free(allSelectors);

	DFHashTable *numStylesByLevel = DFHashTableNew((DFCopyFunction)CSSStyleRetain,(DFFreeFunction)CSSStyleRelease);

	for (int i = 0; i < 6; i++) {
	SelectorList *list = DFHashTableLookupInt(selectorsByLevel,i);
	SelectorList *next;
	for (SelectorList *item = list; item != NULL; item = next) {
	next = item->next;
	CSSStyle *style = CSSSheetLookupSelector(cssSheet,item->selector,0,0);
	// FIXME: need to do this comparison based on lvlText
	if ((CSSGet(CSSStyleBefore(style),"content") != NULL) &&
	!DFStringEquals(CSSGet(CSSStyleBefore(style),"content"),"none") &&
	!DFStringEquals(CSSGet(CSSStyleBefore(style),"content"),"\"\"")) {
	DFHashTableAddInt(numStylesByLevel,i,style);
	}
	free(item->selector);
	free(item);
	}
	}

	for (int i = 0; i < 6; i++) {
	CSSStyle *style = DFHashTableLookupInt(numStylesByLevel,i);
	char *curType = NULL;
	char *curLvlText = NULL;
	WordNumInfo *info = NULL;


	if (style != NULL) {
	info = DFHashTableLookup(infoByStyleId,style->selector);
	if (info == NULL) {
	info = WordNumInfoNew();
	DFHashTableAdd(infoByStyleId,style->selector,info);
	}
	curType = xstrdup(info->cssType);
	curLvlText = xstrdup(info->cssLvlText);
	}


	if (curType == NULL)
	curType = (prevType != NULL) ? xstrdup(prevType) : xstrdup("decimal");

	if ((curLvlText == NULL) \|\| (strlen(curLvlText) == 0)) {
	free(curLvlText);
	if ((prevLvlText == NULL) \|\| (strlen(prevLvlText) == 0))
	curLvlText = DFFormatString("%%%d",i+1);
	else
	curLvlText = DFFormatString("%s.%%%d",prevLvlText,i+1);
	}

	WordNumLevel *numLevel = WordNumberingCreateLevel(converter->numbering,curType,curLvlText,i,0);
	DFAppendChild(abstractNum->element,numLevel->element);
	WordAbstractNumAddLevel(abstractNum,numLevel);

	if (info != NULL) {
	info->wordLevel = numLevel;
	assert(info->wordLevel != NULL);
	free(info->wordNumId);
	free(info->wordIlvl);
	info->wordNumId = xstrdup(concreteNum->numId);
	info->wordIlvl = DFFormatString("%d",i);
	}

	free(prevType);
	free(prevLvlText);
	prevType = curType;
	prevLvlText = curLvlText;
	}
	free(prevType);
	free(prevLvlText);
	DFHashTableRelease(selectorsByLevel);
	DFHashTableRelease(numStylesByLevel);
	}

	cssSelectors = DFHashTableCopyKeys(infoByStyleId);
	for (int i = 0; cssSelectors[i]; i++) {
	const char *selector = cssSelectors[i];
	WordNumInfo *info = DFHashTableLookup(infoByStyleId,selector);
	CSSStyle *cssStyle = CSSSheetLookupSelector(cssSheet,selector,0,0);
	if (cssStyle != NULL) {
	CSSPut(CSSStyleRule(cssStyle),"-word-numId",info->wordNumId);
	if (DFStringEquals(info->wordIlvl,"0"))
	CSSPut(CSSStyleRule(cssStyle),"-word-ilvl",NULL);
	else
	CSSPut(CSSStyleRule(cssStyle),"-word-ilvl",info->wordIlvl);
	}
	}
	free(cssSelectors);
	DFHashTableRelease(infoByStyleId);
	}