RenderBox::parent/firstChild/nextSibling/previousSiblingBox() functions should type...
[WebKit-https.git] / Source / WebCore / rendering / RenderListMarker.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
5  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
6  * Copyright (C) 2010 Daniel Bates (dbates@intudata.com)
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #include "config.h"
26 #include "RenderListMarker.h"
27
28 #include "Document.h"
29 #include "FontCascade.h"
30 #include "GraphicsContext.h"
31 #include "InlineElementBox.h"
32 #include "RenderLayer.h"
33 #include "RenderListItem.h"
34 #include "RenderView.h"
35 #include <wtf/IsoMallocInlines.h>
36 #include <wtf/StackStats.h>
37 #include <wtf/text/StringBuilder.h>
38 #include <wtf/unicode/CharacterNames.h>
39
40
41 namespace WebCore {
42 using namespace WTF;
43 using namespace Unicode;
44
45 WTF_MAKE_ISO_ALLOCATED_IMPL(RenderListMarker);
46
47 const int cMarkerPadding = 7;
48
49 enum SequenceType { NumericSequence, AlphabeticSequence };
50
51 static NEVER_INLINE void toRoman(StringBuilder& builder, int number, bool upper)
52 {
53     // FIXME: CSS3 describes how to make this work for much larger numbers,
54     // using overbars and special characters. It also specifies the characters
55     // in the range U+2160 to U+217F instead of standard ASCII ones.
56     ASSERT(number >= 1 && number <= 3999);
57
58     // Big enough to store largest roman number less than 3999 which
59     // is 3888 (MMMDCCCLXXXVIII)
60     const int lettersSize = 15;
61     LChar letters[lettersSize];
62
63     int length = 0;
64     const LChar ldigits[] = { 'i', 'v', 'x', 'l', 'c', 'd', 'm' };
65     const LChar udigits[] = { 'I', 'V', 'X', 'L', 'C', 'D', 'M' };
66     const LChar* digits = upper ? udigits : ldigits;
67     int d = 0;
68     do {
69         int num = number % 10;
70         if (num % 5 < 4)
71             for (int i = num % 5; i > 0; i--)
72                 letters[lettersSize - ++length] = digits[d];
73         if (num >= 4 && num <= 8)
74             letters[lettersSize - ++length] = digits[d + 1];
75         if (num == 9)
76             letters[lettersSize - ++length] = digits[d + 2];
77         if (num % 5 == 4)
78             letters[lettersSize - ++length] = digits[d];
79         number /= 10;
80         d += 2;
81     } while (number);
82
83     ASSERT(length <= lettersSize);
84     builder.append(&letters[lettersSize - length], length);
85 }
86
87 template <typename CharacterType>
88 static inline void toAlphabeticOrNumeric(StringBuilder& builder, int number, const CharacterType* sequence, unsigned sequenceSize, SequenceType type)
89 {
90     ASSERT(sequenceSize >= 2);
91
92     // Taking sizeof(number) in the expression below doesn't work with some compilers.
93     const int lettersSize = sizeof(int) * 8 + 1; // Binary is the worst case; requires one character per bit plus a minus sign.
94
95     CharacterType letters[lettersSize];
96
97     bool isNegativeNumber = false;
98     unsigned numberShadow = number;
99     if (type == AlphabeticSequence) {
100         ASSERT(number > 0);
101         --numberShadow;
102     } else if (number < 0) {
103         numberShadow = -number;
104         isNegativeNumber = true;
105     }
106     letters[lettersSize - 1] = sequence[numberShadow % sequenceSize];
107     int length = 1;
108
109     if (type == AlphabeticSequence) {
110         while ((numberShadow /= sequenceSize) > 0) {
111             --numberShadow;
112             letters[lettersSize - ++length] = sequence[numberShadow % sequenceSize];
113         }
114     } else {
115         while ((numberShadow /= sequenceSize) > 0)
116             letters[lettersSize - ++length] = sequence[numberShadow % sequenceSize];
117     }
118     if (isNegativeNumber)
119         letters[lettersSize - ++length] = hyphenMinus;
120
121     ASSERT(length <= lettersSize);
122     builder.append(&letters[lettersSize - length], length);
123 }
124
125 template <typename CharacterType>
126 static NEVER_INLINE void toSymbolic(StringBuilder& builder, int number, const CharacterType* symbols, unsigned symbolsSize)
127 {
128     ASSERT(number > 0);
129     ASSERT(symbolsSize >= 1);
130     unsigned numberShadow = number;
131     --numberShadow;
132
133     // The asterisks list-style-type is the worst case; we show |numberShadow| asterisks.
134     builder.append(symbols[numberShadow % symbolsSize]);
135     unsigned numSymbols = numberShadow / symbolsSize;
136     while (numSymbols--)
137         builder.append(symbols[numberShadow % symbolsSize]);
138 }
139
140 template <typename CharacterType>
141 static NEVER_INLINE void toAlphabetic(StringBuilder& builder, int number, const CharacterType* alphabet, unsigned alphabetSize)
142 {
143     toAlphabeticOrNumeric(builder, number, alphabet, alphabetSize, AlphabeticSequence);
144 }
145
146 template <typename CharacterType>
147 static NEVER_INLINE void toNumeric(StringBuilder& builder, int number, const CharacterType* numerals, unsigned numeralsSize)
148 {
149     toAlphabeticOrNumeric(builder, number, numerals, numeralsSize, NumericSequence);
150 }
151
152 template <typename CharacterType, size_t size>
153 static inline void toAlphabetic(StringBuilder& builder, int number, const CharacterType(&alphabet)[size])
154 {
155     toAlphabetic(builder, number, alphabet, size);
156 }
157
158 template <typename CharacterType, size_t size>
159 static inline void toNumeric(StringBuilder& builder, int number, const CharacterType(&alphabet)[size])
160 {
161     toNumeric(builder, number, alphabet, size);
162 }
163
164 template <typename CharacterType, size_t size>
165 static inline void toSymbolic(StringBuilder& builder, int number, const CharacterType(&alphabet)[size])
166 {    
167     toSymbolic(builder, number, alphabet, size);
168 }
169
170 static NEVER_INLINE int toHebrewUnder1000(int number, UChar letters[5])
171 {
172     // FIXME: CSS3 mentions various refinements not implemented here.
173     // FIXME: Should take a look at Mozilla's HebrewToText function (in nsBulletFrame).
174     ASSERT(number >= 0 && number < 1000);
175     int length = 0;
176     int fourHundreds = number / 400;
177     for (int i = 0; i < fourHundreds; i++)
178         letters[length++] = 1511 + 3;
179     number %= 400;
180     if (number / 100)
181         letters[length++] = 1511 + (number / 100) - 1;
182     number %= 100;
183     if (number == 15 || number == 16) {
184         letters[length++] = 1487 + 9;
185         letters[length++] = 1487 + number - 9;
186     } else {
187         if (int tens = number / 10) {
188             static const UChar hebrewTens[9] = { 1497, 1499, 1500, 1502, 1504, 1505, 1506, 1508, 1510 };
189             letters[length++] = hebrewTens[tens - 1];
190         }
191         if (int ones = number % 10)
192             letters[length++] = 1487 + ones;
193     }
194     ASSERT(length <= 5);
195     return length;
196 }
197
198 static NEVER_INLINE void toHebrew(StringBuilder& builder, int number)
199 {
200     // FIXME: CSS3 mentions ways to make this work for much larger numbers.
201     ASSERT(number >= 0 && number <= 999999);
202
203     if (number == 0) {
204         static const UChar hebrewZero[3] = { 0x05D0, 0x05E4, 0x05E1 };
205         builder.append(hebrewZero, 3);
206         return;
207     }
208
209     const int lettersSize = 11; // big enough for two 5-digit sequences plus a quote mark between
210     UChar letters[lettersSize];
211
212     int length;
213     if (number < 1000)
214         length = 0;
215     else {
216         length = toHebrewUnder1000(number / 1000, letters);
217         letters[length++] = '\'';
218         number = number % 1000;
219     }
220     length += toHebrewUnder1000(number, letters + length);
221
222     ASSERT(length <= lettersSize);
223     builder.append(letters, length);
224 }
225
226 static NEVER_INLINE int toArmenianUnder10000(int number, bool upper, bool addCircumflex, UChar letters[9])
227 {
228     ASSERT(number >= 0 && number < 10000);
229     int length = 0;
230
231     int lowerOffset = upper ? 0 : 0x0030;
232
233     if (int thousands = number / 1000) {
234         if (thousands == 7) {
235             letters[length++] = 0x0552 + lowerOffset;
236             if (addCircumflex)
237                 letters[length++] = 0x0302;
238         } else {
239             letters[length++] = (0x054C - 1 + lowerOffset) + thousands;
240             if (addCircumflex)
241                 letters[length++] = 0x0302;
242         }
243     }
244
245     if (int hundreds = (number / 100) % 10) {
246         letters[length++] = (0x0543 - 1 + lowerOffset) + hundreds;
247         if (addCircumflex)
248             letters[length++] = 0x0302;
249     }
250
251     if (int tens = (number / 10) % 10) {
252         letters[length++] = (0x053A - 1 + lowerOffset) + tens;
253         if (addCircumflex)
254             letters[length++] = 0x0302;
255     }
256
257     if (int ones = number % 10) {
258         letters[length++] = (0x531 - 1 + lowerOffset) + ones;
259         if (addCircumflex)
260             letters[length++] = 0x0302;
261     }
262
263     return length;
264 }
265
266 static NEVER_INLINE void toArmenian(StringBuilder& builder, int number, bool upper)
267 {
268     ASSERT(number >= 1 && number <= 99999999);
269
270     const int lettersSize = 18; // twice what toArmenianUnder10000 needs
271     UChar letters[lettersSize];
272
273     int length = toArmenianUnder10000(number / 10000, upper, true, letters);
274     length += toArmenianUnder10000(number % 10000, upper, false, letters + length);
275
276     ASSERT(length <= lettersSize);
277     builder.append(letters, length);
278 }
279
280 static NEVER_INLINE void toGeorgian(StringBuilder& builder, int number)
281 {
282     ASSERT(number >= 1 && number <= 19999);
283
284     const int lettersSize = 5;
285     UChar letters[lettersSize];
286
287     int length = 0;
288
289     if (number > 9999)
290         letters[length++] = 0x10F5;
291
292     if (int thousands = (number / 1000) % 10) {
293         static const UChar georgianThousands[9] = {
294             0x10E9, 0x10EA, 0x10EB, 0x10EC, 0x10ED, 0x10EE, 0x10F4, 0x10EF, 0x10F0
295         };
296         letters[length++] = georgianThousands[thousands - 1];
297     }
298
299     if (int hundreds = (number / 100) % 10) {
300         static const UChar georgianHundreds[9] = {
301             0x10E0, 0x10E1, 0x10E2, 0x10F3, 0x10E4, 0x10E5, 0x10E6, 0x10E7, 0x10E8
302         };
303         letters[length++] = georgianHundreds[hundreds - 1];
304     }
305
306     if (int tens = (number / 10) % 10) {
307         static const UChar georgianTens[9] = {
308             0x10D8, 0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10F2, 0x10DD, 0x10DE, 0x10DF
309         };
310         letters[length++] = georgianTens[tens - 1];
311     }
312
313     if (int ones = number % 10) {
314         static const UChar georgianOnes[9] = {
315             0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10F1, 0x10D7
316         };
317         letters[length++] = georgianOnes[ones - 1];
318     }
319
320     ASSERT(length <= lettersSize);
321     builder.append(letters, length);
322 }
323
324 // The table uses the order from the CSS3 specification:
325 // first 3 group markers, then 3 digit markers, then ten digits.
326 static NEVER_INLINE void toCJKIdeographic(StringBuilder& builder, int number, const UChar table[16])
327 {
328     ASSERT(number >= 0);
329
330     enum AbstractCJKChar {
331         noChar,
332         secondGroupMarker, thirdGroupMarker, fourthGroupMarker,
333         secondDigitMarker, thirdDigitMarker, fourthDigitMarker,
334         digit0, digit1, digit2, digit3, digit4,
335         digit5, digit6, digit7, digit8, digit9
336     };
337
338     if (number == 0) {
339         builder.append(table[digit0 - 1]);
340         return;
341     }
342
343     const int groupLength = 8; // 4 digits, 3 digit markers, and a group marker
344     const int bufferLength = 4 * groupLength;
345     AbstractCJKChar buffer[bufferLength] = { noChar };
346
347     for (int i = 0; i < 4; ++i) {
348         int groupValue = number % 10000;
349         number /= 10000;
350
351         // Process least-significant group first, but put it in the buffer last.
352         AbstractCJKChar* group = &buffer[(3 - i) * groupLength];
353
354         if (groupValue && i)
355             group[7] = static_cast<AbstractCJKChar>(secondGroupMarker - 1 + i);
356
357         // Put in the four digits and digit markers for any non-zero digits.
358         group[6] = static_cast<AbstractCJKChar>(digit0 + (groupValue % 10));
359         if (number != 0 || groupValue > 9) {
360             int digitValue = ((groupValue / 10) % 10);
361             group[4] = static_cast<AbstractCJKChar>(digit0 + digitValue);
362             if (digitValue)
363                 group[5] = secondDigitMarker;
364         }
365         if (number != 0 || groupValue > 99) {
366             int digitValue = ((groupValue / 100) % 10);
367             group[2] = static_cast<AbstractCJKChar>(digit0 + digitValue);
368             if (digitValue)
369                 group[3] = thirdDigitMarker;
370         }
371         if (number != 0 || groupValue > 999) {
372             int digitValue = groupValue / 1000;
373             group[0] = static_cast<AbstractCJKChar>(digit0 + digitValue);
374             if (digitValue)
375                 group[1] = fourthDigitMarker;
376         }
377
378         // Remove the tens digit, but leave the marker, for any group that has
379         // a value of less than 20.
380         if (groupValue < 20) {
381             ASSERT(group[4] == noChar || group[4] == digit0 || group[4] == digit1);
382             group[4] = noChar;
383         }
384
385         if (number == 0)
386             break;
387     }
388
389     // Convert into characters, omitting consecutive runs of digit0 and
390     // any trailing digit0.
391     int length = 0;
392     UChar characters[bufferLength];
393     AbstractCJKChar last = noChar;
394     for (int i = 0; i < bufferLength; ++i) {
395         AbstractCJKChar a = buffer[i];
396         if (a != noChar) {
397             if (a != digit0 || last != digit0)
398                 characters[length++] = table[a - 1];
399             last = a;
400         }
401     }
402     if (last == digit0)
403         --length;
404
405     builder.append(characters, length);
406 }
407
408 static EListStyleType effectiveListMarkerType(EListStyleType type, int value)
409 {
410     // Note, the following switch statement has been explicitly grouped
411     // by list-style-type ordinal range.
412     switch (type) {
413     case ArabicIndic:
414     case Bengali:
415     case BinaryListStyle:
416     case Cambodian:
417     case Circle:
418     case DecimalLeadingZero:
419     case DecimalListStyle:
420     case Devanagari:
421     case Disc:
422     case Gujarati:
423     case Gurmukhi:
424     case Kannada:
425     case Khmer:
426     case Lao:
427     case LowerHexadecimal:
428     case Malayalam:
429     case Mongolian:
430     case Myanmar:
431     case NoneListStyle:
432     case Octal:
433     case Oriya:
434     case Persian:
435     case Square:
436     case Telugu:
437     case Thai:
438     case Tibetan:
439     case UpperHexadecimal:
440     case Urdu:
441         return type; // Can represent all ordinals.
442     case Armenian:
443         return (value < 1 || value > 99999999) ? DecimalListStyle : type;
444     case CJKIdeographic:
445         return (value < 0) ? DecimalListStyle : type;
446     case Georgian:
447         return (value < 1 || value > 19999) ? DecimalListStyle : type;
448     case Hebrew:
449         return (value < 0 || value > 999999) ? DecimalListStyle : type;
450     case LowerRoman:
451     case UpperRoman:
452         return (value < 1 || value > 3999) ? DecimalListStyle : type;
453     case Afar:
454     case Amharic:
455     case AmharicAbegede:
456     case Asterisks:
457     case CjkEarthlyBranch:
458     case CjkHeavenlyStem:
459     case Ethiopic:
460     case EthiopicAbegede:
461     case EthiopicAbegedeAmEt:
462     case EthiopicAbegedeGez:
463     case EthiopicAbegedeTiEr:
464     case EthiopicAbegedeTiEt:
465     case EthiopicHalehameAaEr:
466     case EthiopicHalehameAaEt:
467     case EthiopicHalehameAmEt:
468     case EthiopicHalehameGez:
469     case EthiopicHalehameOmEt:
470     case EthiopicHalehameSidEt:
471     case EthiopicHalehameSoEt:
472     case EthiopicHalehameTiEr:
473     case EthiopicHalehameTiEt:
474     case EthiopicHalehameTig:
475     case Footnotes:
476     case Hangul:
477     case HangulConsonant:
478     case Hiragana:
479     case HiraganaIroha:
480     case Katakana:
481     case KatakanaIroha:
482     case LowerAlpha:
483     case LowerArmenian:
484     case LowerGreek:
485     case LowerLatin:
486     case LowerNorwegian:
487     case Oromo:
488     case Sidama:
489     case Somali:
490     case Tigre:
491     case TigrinyaEr:
492     case TigrinyaErAbegede:
493     case TigrinyaEt:
494     case TigrinyaEtAbegede:
495     case UpperAlpha:
496     case UpperArmenian:
497     case UpperGreek:
498     case UpperLatin:
499     case UpperNorwegian:
500         return (value < 1) ? DecimalListStyle : type;
501     }
502
503     ASSERT_NOT_REACHED();
504     return type;
505 }
506
507 static UChar listMarkerSuffix(EListStyleType type, int value)
508 {
509     // If the list-style-type cannot represent |value| because it's outside its
510     // ordinal range then we fall back to some list style that can represent |value|.
511     EListStyleType effectiveType = effectiveListMarkerType(type, value);
512
513     // Note, the following switch statement has been explicitly
514     // grouped by list-style-type suffix.
515     switch (effectiveType) {
516     case Asterisks:
517     case Circle:
518     case Disc:
519     case Footnotes:
520     case NoneListStyle:
521     case Square:
522         return ' ';
523     case Afar:
524     case Amharic:
525     case AmharicAbegede:
526     case Ethiopic:
527     case EthiopicAbegede:
528     case EthiopicAbegedeAmEt:
529     case EthiopicAbegedeGez:
530     case EthiopicAbegedeTiEr:
531     case EthiopicAbegedeTiEt:
532     case EthiopicHalehameAaEr:
533     case EthiopicHalehameAaEt:
534     case EthiopicHalehameAmEt:
535     case EthiopicHalehameGez:
536     case EthiopicHalehameOmEt:
537     case EthiopicHalehameSidEt:
538     case EthiopicHalehameSoEt:
539     case EthiopicHalehameTiEr:
540     case EthiopicHalehameTiEt:
541     case EthiopicHalehameTig:
542     case Oromo:
543     case Sidama:
544     case Somali:
545     case Tigre:
546     case TigrinyaEr:
547     case TigrinyaErAbegede:
548     case TigrinyaEt:
549     case TigrinyaEtAbegede:
550         return ethiopicPrefaceColon;
551     case Armenian:
552     case ArabicIndic:
553     case Bengali:
554     case BinaryListStyle:
555     case Cambodian:
556     case CJKIdeographic:
557     case CjkEarthlyBranch:
558     case CjkHeavenlyStem:
559     case DecimalLeadingZero:
560     case DecimalListStyle:
561     case Devanagari:
562     case Georgian:
563     case Gujarati:
564     case Gurmukhi:
565     case Hangul:
566     case HangulConsonant:
567     case Hebrew:
568     case Hiragana:
569     case HiraganaIroha:
570     case Kannada:
571     case Katakana:
572     case KatakanaIroha:
573     case Khmer:
574     case Lao:
575     case LowerAlpha:
576     case LowerArmenian:
577     case LowerGreek:
578     case LowerHexadecimal:
579     case LowerLatin:
580     case LowerNorwegian:
581     case LowerRoman:
582     case Malayalam:
583     case Mongolian:
584     case Myanmar:
585     case Octal:
586     case Oriya:
587     case Persian:
588     case Telugu:
589     case Thai:
590     case Tibetan:
591     case UpperAlpha:
592     case UpperArmenian:
593     case UpperGreek:
594     case UpperHexadecimal:
595     case UpperLatin:
596     case UpperNorwegian:
597     case UpperRoman:
598     case Urdu:
599         return '.';
600     }
601
602     ASSERT_NOT_REACHED();
603     return '.';
604 }
605
606 String listMarkerText(EListStyleType type, int value)
607 {
608     StringBuilder builder;
609
610     // If the list-style-type, say hebrew, cannot represent |value| because it's outside
611     // its ordinal range then we fallback to some list style that can represent |value|.
612     switch (effectiveListMarkerType(type, value)) {
613         case NoneListStyle:
614             return emptyString();
615
616         case Asterisks: {
617             static const LChar asterisksSymbols[1] = { 0x2A };
618             toSymbolic(builder, value, asterisksSymbols);
619             break;
620         }
621         // We use the same characters for text security.
622         // See RenderText::setInternalString.
623         case Circle:
624             builder.append(whiteBullet);
625             break;
626         case Disc:
627             builder.append(bullet);
628             break;
629         case Footnotes: {
630             static const UChar footnotesSymbols[4] = { 0x002A, 0x2051, 0x2020, 0x2021 };
631             toSymbolic(builder, value, footnotesSymbols);
632             break;
633         }
634         case Square:
635             // The CSS 2.1 test suite uses U+25EE BLACK MEDIUM SMALL SQUARE
636             // instead, but I think this looks better.
637             builder.append(blackSquare);
638             break;
639
640         case DecimalListStyle:
641             builder.appendNumber(value);
642             break;
643
644         case DecimalLeadingZero:
645             if (value < -9 || value > 9) {
646                 builder.appendNumber(value);
647                 break;
648             }
649             if (value < 0) {
650                 builder.appendLiteral("-0");
651                 builder.appendNumber(-value); // -01 to -09
652                 break;
653             }
654             builder.append('0');
655             builder.appendNumber(value); // 00 to 09
656             break;
657
658         case ArabicIndic: {
659             static const UChar arabicIndicNumerals[10] = {
660                 0x0660, 0x0661, 0x0662, 0x0663, 0x0664, 0x0665, 0x0666, 0x0667, 0x0668, 0x0669
661             };
662             toNumeric(builder, value, arabicIndicNumerals);
663             break;
664         }
665
666         case BinaryListStyle: {
667             static const LChar binaryNumerals[2] = { '0', '1' };
668             toNumeric(builder, value, binaryNumerals);
669             break;
670         }
671
672         case Bengali: {
673             static const UChar bengaliNumerals[10] = {
674                 0x09E6, 0x09E7, 0x09E8, 0x09E9, 0x09EA, 0x09EB, 0x09EC, 0x09ED, 0x09EE, 0x09EF
675             };
676             toNumeric(builder, value, bengaliNumerals);
677             break;
678         }
679
680         case Cambodian:
681         case Khmer: {
682             static const UChar khmerNumerals[10] = {
683                 0x17E0, 0x17E1, 0x17E2, 0x17E3, 0x17E4, 0x17E5, 0x17E6, 0x17E7, 0x17E8, 0x17E9
684             };
685             toNumeric(builder, value, khmerNumerals);
686             break;
687         }
688         case Devanagari: {
689             static const UChar devanagariNumerals[10] = {
690                 0x0966, 0x0967, 0x0968, 0x0969, 0x096A, 0x096B, 0x096C, 0x096D, 0x096E, 0x096F
691             };
692             toNumeric(builder, value, devanagariNumerals);
693             break;
694         }
695         case Gujarati: {
696             static const UChar gujaratiNumerals[10] = {
697                 0x0AE6, 0x0AE7, 0x0AE8, 0x0AE9, 0x0AEA, 0x0AEB, 0x0AEC, 0x0AED, 0x0AEE, 0x0AEF
698             };
699             toNumeric(builder, value, gujaratiNumerals);
700             break;
701         }
702         case Gurmukhi: {
703             static const UChar gurmukhiNumerals[10] = {
704                 0x0A66, 0x0A67, 0x0A68, 0x0A69, 0x0A6A, 0x0A6B, 0x0A6C, 0x0A6D, 0x0A6E, 0x0A6F
705             };
706             toNumeric(builder, value, gurmukhiNumerals);
707             break;
708         }
709         case Kannada: {
710             static const UChar kannadaNumerals[10] = {
711                 0x0CE6, 0x0CE7, 0x0CE8, 0x0CE9, 0x0CEA, 0x0CEB, 0x0CEC, 0x0CED, 0x0CEE, 0x0CEF
712             };
713             toNumeric(builder, value, kannadaNumerals);
714             break;
715         }
716         case LowerHexadecimal: {
717             static const LChar lowerHexadecimalNumerals[16] = {
718                 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
719             };
720             toNumeric(builder, value, lowerHexadecimalNumerals);
721             break;
722         }
723         case Lao: {
724             static const UChar laoNumerals[10] = {
725                 0x0ED0, 0x0ED1, 0x0ED2, 0x0ED3, 0x0ED4, 0x0ED5, 0x0ED6, 0x0ED7, 0x0ED8, 0x0ED9
726             };
727             toNumeric(builder, value, laoNumerals);
728             break;
729         }
730         case Malayalam: {
731             static const UChar malayalamNumerals[10] = {
732                 0x0D66, 0x0D67, 0x0D68, 0x0D69, 0x0D6A, 0x0D6B, 0x0D6C, 0x0D6D, 0x0D6E, 0x0D6F
733             };
734             toNumeric(builder, value, malayalamNumerals);
735             break;
736         }
737         case Mongolian: {
738             static const UChar mongolianNumerals[10] = {
739                 0x1810, 0x1811, 0x1812, 0x1813, 0x1814, 0x1815, 0x1816, 0x1817, 0x1818, 0x1819
740             };
741             toNumeric(builder, value, mongolianNumerals);
742             break;
743         }
744         case Myanmar: {
745             static const UChar myanmarNumerals[10] = {
746                 0x1040, 0x1041, 0x1042, 0x1043, 0x1044, 0x1045, 0x1046, 0x1047, 0x1048, 0x1049
747             };
748             toNumeric(builder, value, myanmarNumerals);
749             break;
750         }
751         case Octal: {
752             static const LChar octalNumerals[8] = {
753                 '0', '1', '2', '3', '4', '5', '6', '7'
754             };
755             toNumeric(builder, value, octalNumerals);
756             break;
757         }
758         case Oriya: {
759             static const UChar oriyaNumerals[10] = {
760                 0x0B66, 0x0B67, 0x0B68, 0x0B69, 0x0B6A, 0x0B6B, 0x0B6C, 0x0B6D, 0x0B6E, 0x0B6F
761             };
762             toNumeric(builder, value, oriyaNumerals);
763             break;
764         }
765         case Persian:
766         case Urdu: {
767             static const UChar urduNumerals[10] = {
768                 0x06F0, 0x06F1, 0x06F2, 0x06F3, 0x06F4, 0x06F5, 0x06F6, 0x06F7, 0x06F8, 0x06F9
769             };
770             toNumeric(builder, value, urduNumerals);
771             break;
772         }
773         case Telugu: {
774             static const UChar teluguNumerals[10] = {
775                 0x0C66, 0x0C67, 0x0C68, 0x0C69, 0x0C6A, 0x0C6B, 0x0C6C, 0x0C6D, 0x0C6E, 0x0C6F
776             };
777             toNumeric(builder, value, teluguNumerals);
778             break;
779         }
780         case Tibetan: {
781             static const UChar tibetanNumerals[10] = {
782                 0x0F20, 0x0F21, 0x0F22, 0x0F23, 0x0F24, 0x0F25, 0x0F26, 0x0F27, 0x0F28, 0x0F29
783             };
784             toNumeric(builder, value, tibetanNumerals);
785             break;
786         }
787         case Thai: {
788             static const UChar thaiNumerals[10] = {
789                 0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57, 0x0E58, 0x0E59
790             };
791             toNumeric(builder, value, thaiNumerals);
792             break;
793         }
794         case UpperHexadecimal: {
795             static const LChar upperHexadecimalNumerals[16] = {
796                 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
797             };
798             toNumeric(builder, value, upperHexadecimalNumerals);
799             break;
800         }
801
802         case LowerAlpha:
803         case LowerLatin: {
804             static const LChar lowerLatinAlphabet[26] = {
805                 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
806                 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
807             };
808             toAlphabetic(builder, value, lowerLatinAlphabet);
809             break;
810         }
811         case UpperAlpha:
812         case UpperLatin: {
813             static const LChar upperLatinAlphabet[26] = {
814                 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
815                 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
816             };
817             toAlphabetic(builder, value, upperLatinAlphabet);
818             break;
819         }
820         case LowerGreek: {
821             static const UChar lowerGreekAlphabet[24] = {
822                 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8,
823                 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0,
824                 0x03C1, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9
825             };
826             toAlphabetic(builder, value, lowerGreekAlphabet);
827             break;
828         }
829
830         case Hiragana: {
831             // FIXME: This table comes from the CSS3 draft, and is probably
832             // incorrect, given the comments in that draft.
833             static const UChar hiraganaAlphabet[48] = {
834                 0x3042, 0x3044, 0x3046, 0x3048, 0x304A, 0x304B, 0x304D, 0x304F,
835                 0x3051, 0x3053, 0x3055, 0x3057, 0x3059, 0x305B, 0x305D, 0x305F,
836                 0x3061, 0x3064, 0x3066, 0x3068, 0x306A, 0x306B, 0x306C, 0x306D,
837                 0x306E, 0x306F, 0x3072, 0x3075, 0x3078, 0x307B, 0x307E, 0x307F,
838                 0x3080, 0x3081, 0x3082, 0x3084, 0x3086, 0x3088, 0x3089, 0x308A,
839                 0x308B, 0x308C, 0x308D, 0x308F, 0x3090, 0x3091, 0x3092, 0x3093
840             };
841             toAlphabetic(builder, value, hiraganaAlphabet);
842             break;
843         }
844         case HiraganaIroha: {
845             // FIXME: This table comes from the CSS3 draft, and is probably
846             // incorrect, given the comments in that draft.
847             static const UChar hiraganaIrohaAlphabet[47] = {
848                 0x3044, 0x308D, 0x306F, 0x306B, 0x307B, 0x3078, 0x3068, 0x3061,
849                 0x308A, 0x306C, 0x308B, 0x3092, 0x308F, 0x304B, 0x3088, 0x305F,
850                 0x308C, 0x305D, 0x3064, 0x306D, 0x306A, 0x3089, 0x3080, 0x3046,
851                 0x3090, 0x306E, 0x304A, 0x304F, 0x3084, 0x307E, 0x3051, 0x3075,
852                 0x3053, 0x3048, 0x3066, 0x3042, 0x3055, 0x304D, 0x3086, 0x3081,
853                 0x307F, 0x3057, 0x3091, 0x3072, 0x3082, 0x305B, 0x3059
854             };
855             toAlphabetic(builder, value, hiraganaIrohaAlphabet);
856             break;
857         }
858         case Katakana: {
859             // FIXME: This table comes from the CSS3 draft, and is probably
860             // incorrect, given the comments in that draft.
861             static const UChar katakanaAlphabet[48] = {
862                 0x30A2, 0x30A4, 0x30A6, 0x30A8, 0x30AA, 0x30AB, 0x30AD, 0x30AF,
863                 0x30B1, 0x30B3, 0x30B5, 0x30B7, 0x30B9, 0x30BB, 0x30BD, 0x30BF,
864                 0x30C1, 0x30C4, 0x30C6, 0x30C8, 0x30CA, 0x30CB, 0x30CC, 0x30CD,
865                 0x30CE, 0x30CF, 0x30D2, 0x30D5, 0x30D8, 0x30DB, 0x30DE, 0x30DF,
866                 0x30E0, 0x30E1, 0x30E2, 0x30E4, 0x30E6, 0x30E8, 0x30E9, 0x30EA,
867                 0x30EB, 0x30EC, 0x30ED, 0x30EF, 0x30F0, 0x30F1, 0x30F2, 0x30F3
868             };
869             toAlphabetic(builder, value, katakanaAlphabet);
870             break;
871         }
872         case KatakanaIroha: {
873             // FIXME: This table comes from the CSS3 draft, and is probably
874             // incorrect, given the comments in that draft.
875             static const UChar katakanaIrohaAlphabet[47] = {
876                 0x30A4, 0x30ED, 0x30CF, 0x30CB, 0x30DB, 0x30D8, 0x30C8, 0x30C1,
877                 0x30EA, 0x30CC, 0x30EB, 0x30F2, 0x30EF, 0x30AB, 0x30E8, 0x30BF,
878                 0x30EC, 0x30BD, 0x30C4, 0x30CD, 0x30CA, 0x30E9, 0x30E0, 0x30A6,
879                 0x30F0, 0x30CE, 0x30AA, 0x30AF, 0x30E4, 0x30DE, 0x30B1, 0x30D5,
880                 0x30B3, 0x30A8, 0x30C6, 0x30A2, 0x30B5, 0x30AD, 0x30E6, 0x30E1,
881                 0x30DF, 0x30B7, 0x30F1, 0x30D2, 0x30E2, 0x30BB, 0x30B9
882             };
883             toAlphabetic(builder, value, katakanaIrohaAlphabet);
884             break;
885         }
886
887         case Afar:
888         case EthiopicHalehameAaEt:
889         case EthiopicHalehameAaEr: {
890             static const UChar ethiopicHalehameAaErAlphabet[18] = {
891                 0x1200, 0x1208, 0x1210, 0x1218, 0x1228, 0x1230, 0x1260, 0x1270, 0x1290,
892                 0x12A0, 0x12A8, 0x12C8, 0x12D0, 0x12E8, 0x12F0, 0x1308, 0x1338, 0x1348
893             };
894             toAlphabetic(builder, value, ethiopicHalehameAaErAlphabet);
895             break;
896         }
897         case Amharic:
898         case EthiopicHalehameAmEt: {
899             static const UChar ethiopicHalehameAmEtAlphabet[33] = {
900                 0x1200, 0x1208, 0x1210, 0x1218, 0x1220, 0x1228, 0x1230, 0x1238, 0x1240,
901                 0x1260, 0x1270, 0x1278, 0x1280, 0x1290, 0x1298, 0x12A0, 0x12A8, 0x12B8,
902                 0x12C8, 0x12D0, 0x12D8, 0x12E0, 0x12E8, 0x12F0, 0x1300, 0x1308, 0x1320,
903                 0x1328, 0x1330, 0x1338, 0x1340, 0x1348, 0x1350
904             };
905             toAlphabetic(builder, value, ethiopicHalehameAmEtAlphabet);
906             break;
907         }
908         case AmharicAbegede:
909         case EthiopicAbegedeAmEt: {
910             static const UChar ethiopicAbegedeAmEtAlphabet[33] = {
911                 0x12A0, 0x1260, 0x1308, 0x12F0, 0x1300, 0x1200, 0x12C8, 0x12D8, 0x12E0,
912                 0x1210, 0x1320, 0x1328, 0x12E8, 0x12A8, 0x12B8, 0x1208, 0x1218, 0x1290,
913                 0x1298, 0x1220, 0x12D0, 0x1348, 0x1338, 0x1240, 0x1228, 0x1230, 0x1238,
914                 0x1270, 0x1278, 0x1280, 0x1340, 0x1330, 0x1350
915             };
916             toAlphabetic(builder, value, ethiopicAbegedeAmEtAlphabet);
917             break;
918         }
919         case CjkEarthlyBranch: {
920             static const UChar cjkEarthlyBranchAlphabet[12] = {
921                 0x5B50, 0x4E11, 0x5BC5, 0x536F, 0x8FB0, 0x5DF3, 0x5348, 0x672A, 0x7533,
922                 0x9149, 0x620C, 0x4EA5
923             };
924             toAlphabetic(builder, value, cjkEarthlyBranchAlphabet);
925             break;
926         }
927         case CjkHeavenlyStem: {
928             static const UChar cjkHeavenlyStemAlphabet[10] = {
929                 0x7532, 0x4E59, 0x4E19, 0x4E01, 0x620A, 0x5DF1, 0x5E9A, 0x8F9B, 0x58EC,
930                 0x7678
931             };
932             toAlphabetic(builder, value, cjkHeavenlyStemAlphabet);
933             break;
934         }
935         case Ethiopic:
936         case EthiopicHalehameGez: {
937             static const UChar ethiopicHalehameGezAlphabet[26] = {
938                 0x1200, 0x1208, 0x1210, 0x1218, 0x1220, 0x1228, 0x1230, 0x1240, 0x1260,
939                 0x1270, 0x1280, 0x1290, 0x12A0, 0x12A8, 0x12C8, 0x12D0, 0x12D8, 0x12E8,
940                 0x12F0, 0x1308, 0x1320, 0x1330, 0x1338, 0x1340, 0x1348, 0x1350
941             };
942             toAlphabetic(builder, value, ethiopicHalehameGezAlphabet);
943             break;
944         }
945         case EthiopicAbegede:
946         case EthiopicAbegedeGez: {
947             static const UChar ethiopicAbegedeGezAlphabet[26] = {
948                 0x12A0, 0x1260, 0x1308, 0x12F0, 0x1200, 0x12C8, 0x12D8, 0x1210, 0x1320,
949                 0x12E8, 0x12A8, 0x1208, 0x1218, 0x1290, 0x1220, 0x12D0, 0x1348, 0x1338,
950                 0x1240, 0x1228, 0x1230, 0x1270, 0x1280, 0x1340, 0x1330, 0x1350
951             };
952             toAlphabetic(builder, value, ethiopicAbegedeGezAlphabet);
953             break;
954         }
955         case HangulConsonant: {
956             static const UChar hangulConsonantAlphabet[14] = {
957                 0x3131, 0x3134, 0x3137, 0x3139, 0x3141, 0x3142, 0x3145, 0x3147, 0x3148,
958                 0x314A, 0x314B, 0x314C, 0x314D, 0x314E
959             };
960             toAlphabetic(builder, value, hangulConsonantAlphabet);
961             break;
962         }
963         case Hangul: {
964             static const UChar hangulAlphabet[14] = {
965                 0xAC00, 0xB098, 0xB2E4, 0xB77C, 0xB9C8, 0xBC14, 0xC0AC, 0xC544, 0xC790,
966                 0xCC28, 0xCE74, 0xD0C0, 0xD30C, 0xD558
967             };
968             toAlphabetic(builder, value, hangulAlphabet);
969             break;
970         }
971         case Oromo:
972         case EthiopicHalehameOmEt: {
973             static const UChar ethiopicHalehameOmEtAlphabet[25] = {
974                 0x1200, 0x1208, 0x1218, 0x1228, 0x1230, 0x1238, 0x1240, 0x1260, 0x1270,
975                 0x1278, 0x1290, 0x1298, 0x12A0, 0x12A8, 0x12C8, 0x12E8, 0x12F0, 0x12F8,
976                 0x1300, 0x1308, 0x1320, 0x1328, 0x1338, 0x1330, 0x1348
977             };
978             toAlphabetic(builder, value, ethiopicHalehameOmEtAlphabet);
979             break;
980         }
981         case Sidama:
982         case EthiopicHalehameSidEt: {
983             static const UChar ethiopicHalehameSidEtAlphabet[26] = {
984                 0x1200, 0x1208, 0x1210, 0x1218, 0x1228, 0x1230, 0x1238, 0x1240, 0x1260,
985                 0x1270, 0x1278, 0x1290, 0x1298, 0x12A0, 0x12A8, 0x12C8, 0x12E8, 0x12F0,
986                 0x12F8, 0x1300, 0x1308, 0x1320, 0x1328, 0x1338, 0x1330, 0x1348
987             };
988             toAlphabetic(builder, value, ethiopicHalehameSidEtAlphabet);
989             break;
990         }
991         case Somali:
992         case EthiopicHalehameSoEt: {
993             static const UChar ethiopicHalehameSoEtAlphabet[22] = {
994                 0x1200, 0x1208, 0x1210, 0x1218, 0x1228, 0x1230, 0x1238, 0x1240, 0x1260,
995                 0x1270, 0x1290, 0x12A0, 0x12A8, 0x12B8, 0x12C8, 0x12D0, 0x12E8, 0x12F0,
996                 0x1300, 0x1308, 0x1338, 0x1348
997             };
998             toAlphabetic(builder, value, ethiopicHalehameSoEtAlphabet);
999             break;
1000         }
1001         case Tigre:
1002         case EthiopicHalehameTig: {
1003             static const UChar ethiopicHalehameTigAlphabet[27] = {
1004                 0x1200, 0x1208, 0x1210, 0x1218, 0x1228, 0x1230, 0x1238, 0x1240, 0x1260,
1005                 0x1270, 0x1278, 0x1290, 0x12A0, 0x12A8, 0x12C8, 0x12D0, 0x12D8, 0x12E8,
1006                 0x12F0, 0x1300, 0x1308, 0x1320, 0x1328, 0x1338, 0x1330, 0x1348, 0x1350
1007             };
1008             toAlphabetic(builder, value, ethiopicHalehameTigAlphabet);
1009             break;
1010         }
1011         case TigrinyaEr:
1012         case EthiopicHalehameTiEr: {
1013             static const UChar ethiopicHalehameTiErAlphabet[31] = {
1014                 0x1200, 0x1208, 0x1210, 0x1218, 0x1228, 0x1230, 0x1238, 0x1240, 0x1250,
1015                 0x1260, 0x1270, 0x1278, 0x1290, 0x1298, 0x12A0, 0x12A8, 0x12B8, 0x12C8,
1016                 0x12D0, 0x12D8, 0x12E0, 0x12E8, 0x12F0, 0x1300, 0x1308, 0x1320, 0x1328,
1017                 0x1330, 0x1338, 0x1348, 0x1350
1018             };
1019             toAlphabetic(builder, value, ethiopicHalehameTiErAlphabet);
1020             break;
1021         }
1022         case TigrinyaErAbegede:
1023         case EthiopicAbegedeTiEr: {
1024             static const UChar ethiopicAbegedeTiErAlphabet[31] = {
1025                 0x12A0, 0x1260, 0x1308, 0x12F0, 0x1300, 0x1200, 0x12C8, 0x12D8, 0x12E0,
1026                 0x1210, 0x1320, 0x1328, 0x12E8, 0x12A8, 0x12B8, 0x1208, 0x1218, 0x1290,
1027                 0x1298, 0x12D0, 0x1348, 0x1338, 0x1240, 0x1250, 0x1228, 0x1230, 0x1238,
1028                 0x1270, 0x1278, 0x1330, 0x1350
1029             };
1030             toAlphabetic(builder, value, ethiopicAbegedeTiErAlphabet);
1031             break;
1032         }
1033         case TigrinyaEt:
1034         case EthiopicHalehameTiEt: {
1035             static const UChar ethiopicHalehameTiEtAlphabet[34] = {
1036                 0x1200, 0x1208, 0x1210, 0x1218, 0x1220, 0x1228, 0x1230, 0x1238, 0x1240,
1037                 0x1250, 0x1260, 0x1270, 0x1278, 0x1280, 0x1290, 0x1298, 0x12A0, 0x12A8,
1038                 0x12B8, 0x12C8, 0x12D0, 0x12D8, 0x12E0, 0x12E8, 0x12F0, 0x1300, 0x1308,
1039                 0x1320, 0x1328, 0x1330, 0x1338, 0x1340, 0x1348, 0x1350
1040             };
1041             toAlphabetic(builder, value, ethiopicHalehameTiEtAlphabet);
1042             break;
1043         }
1044         case TigrinyaEtAbegede:
1045         case EthiopicAbegedeTiEt: {
1046             static const UChar ethiopicAbegedeTiEtAlphabet[34] = {
1047                 0x12A0, 0x1260, 0x1308, 0x12F0, 0x1300, 0x1200, 0x12C8, 0x12D8, 0x12E0,
1048                 0x1210, 0x1320, 0x1328, 0x12E8, 0x12A8, 0x12B8, 0x1208, 0x1218, 0x1290,
1049                 0x1298, 0x1220, 0x12D0, 0x1348, 0x1338, 0x1240, 0x1250, 0x1228, 0x1230,
1050                 0x1238, 0x1270, 0x1278, 0x1280, 0x1340, 0x1330, 0x1350
1051             };
1052             toAlphabetic(builder, value, ethiopicAbegedeTiEtAlphabet);
1053             break;
1054         }
1055         case UpperGreek: {
1056             static const UChar upperGreekAlphabet[24] = {
1057                 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399,
1058                 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0, 0x03A1, 0x03A3,
1059                 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9
1060             };
1061             toAlphabetic(builder, value, upperGreekAlphabet);
1062             break;
1063         }
1064         case LowerNorwegian: {
1065             static const LChar lowerNorwegianAlphabet[29] = {
1066                 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
1067                 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72,
1068                 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xE6,
1069                 0xF8, 0xE5
1070             };
1071             toAlphabetic(builder, value, lowerNorwegianAlphabet);
1072             break;
1073         }
1074         case UpperNorwegian: {
1075             static const LChar upperNorwegianAlphabet[29] = {
1076                 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
1077                 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52,
1078                 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0xC6,
1079                 0xD8, 0xC5
1080             };
1081             toAlphabetic(builder, value, upperNorwegianAlphabet);
1082             break;
1083         }
1084         case CJKIdeographic: {
1085             static const UChar traditionalChineseInformalTable[16] = {
1086                 0x842C, 0x5104, 0x5146,
1087                 0x5341, 0x767E, 0x5343,
1088                 0x96F6, 0x4E00, 0x4E8C, 0x4E09, 0x56DB,
1089                 0x4E94, 0x516D, 0x4E03, 0x516B, 0x4E5D
1090             };
1091             toCJKIdeographic(builder, value, traditionalChineseInformalTable);
1092             break;
1093         }
1094
1095         case LowerRoman:
1096             toRoman(builder, value, false);
1097             break;
1098         case UpperRoman:
1099             toRoman(builder, value, true);
1100             break;
1101
1102         case Armenian:
1103         case UpperArmenian:
1104             // CSS3 says "armenian" means "lower-armenian".
1105             // But the CSS2.1 test suite contains uppercase test results for "armenian",
1106             // so we'll match the test suite.
1107             toArmenian(builder, value, true);
1108             break;
1109         case LowerArmenian:
1110             toArmenian(builder, value, false);
1111             break;
1112         case Georgian:
1113             toGeorgian(builder, value);
1114             break;
1115         case Hebrew:
1116             toHebrew(builder, value);
1117             break;
1118     }
1119
1120     return builder.toString();
1121 }
1122
1123 RenderListMarker::RenderListMarker(RenderListItem& listItem, RenderStyle&& style)
1124     : RenderBox(listItem.document(), WTFMove(style), 0)
1125     , m_listItem(listItem)
1126 {
1127     // init RenderObject attributes
1128     setInline(true);   // our object is Inline
1129     setReplaced(true); // pretend to be replaced
1130 }
1131
1132 RenderListMarker::~RenderListMarker()
1133 {
1134     // Do not add any code here. Add it to willBeDestroyed() instead.
1135 }
1136
1137 void RenderListMarker::willBeDestroyed()
1138 {
1139     if (m_image)
1140         m_image->removeClient(this);
1141     RenderBox::willBeDestroyed();
1142 }
1143
1144 void RenderListMarker::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
1145 {
1146     RenderBox::styleDidChange(diff, oldStyle);
1147
1148     if (oldStyle && (style().listStylePosition() != oldStyle->listStylePosition() || style().listStyleType() != oldStyle->listStyleType()))
1149         setNeedsLayoutAndPrefWidthsRecalc();
1150
1151     if (m_image != style().listStyleImage()) {
1152         if (m_image)
1153             m_image->removeClient(this);
1154         m_image = style().listStyleImage();
1155         if (m_image)
1156             m_image->addClient(this);
1157     }
1158 }
1159
1160 std::unique_ptr<InlineElementBox> RenderListMarker::createInlineBox()
1161 {
1162     auto box = RenderBox::createInlineBox();
1163     box->setBehavesLikeText(isText());
1164     return box;
1165 }
1166
1167 bool RenderListMarker::isImage() const
1168 {
1169     return m_image && !m_image->errorOccurred();
1170 }
1171
1172 LayoutRect RenderListMarker::localSelectionRect()
1173 {
1174     InlineBox* box = inlineBoxWrapper();
1175     if (!box)
1176         return LayoutRect(LayoutPoint(), size());
1177     const RootInlineBox& rootBox = m_inlineBoxWrapper->root();
1178     LayoutUnit newLogicalTop = rootBox.blockFlow().style().isFlippedBlocksWritingMode() ? m_inlineBoxWrapper->logicalBottom() - rootBox.selectionBottom() : rootBox.selectionTop() - m_inlineBoxWrapper->logicalTop();
1179     if (rootBox.blockFlow().style().isHorizontalWritingMode())
1180         return LayoutRect(0, newLogicalTop, width(), rootBox.selectionHeight());
1181     return LayoutRect(newLogicalTop, 0, rootBox.selectionHeight(), height());
1182 }
1183
1184 void RenderListMarker::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
1185 {
1186     if (paintInfo.phase != PaintPhaseForeground)
1187         return;
1188     
1189     if (style().visibility() != VISIBLE)
1190         return;
1191
1192     LayoutPoint boxOrigin(paintOffset + location());
1193     LayoutRect overflowRect(visualOverflowRect());
1194     overflowRect.moveBy(boxOrigin);
1195     if (!paintInfo.rect.intersects(overflowRect))
1196         return;
1197
1198     LayoutRect box(boxOrigin, size());
1199     
1200     auto markerRect = getRelativeMarkerRect();
1201     markerRect.moveBy(boxOrigin);
1202     if (markerRect.isEmpty())
1203         return;
1204
1205     GraphicsContext& context = paintInfo.context();
1206
1207     if (isImage()) {
1208         if (RefPtr<Image> markerImage = m_image->image(this, markerRect.size()))
1209             context.drawImage(*markerImage, markerRect);
1210         if (selectionState() != SelectionNone) {
1211             LayoutRect selRect = localSelectionRect();
1212             selRect.moveBy(boxOrigin);
1213             context.fillRect(snappedIntRect(selRect), m_listItem.selectionBackgroundColor());
1214         }
1215         return;
1216     }
1217
1218     if (selectionState() != SelectionNone) {
1219         LayoutRect selRect = localSelectionRect();
1220         selRect.moveBy(boxOrigin);
1221         context.fillRect(snappedIntRect(selRect), m_listItem.selectionBackgroundColor());
1222     }
1223
1224     const Color color(style().visitedDependentColor(CSSPropertyColor));
1225     context.setStrokeColor(color);
1226     context.setStrokeStyle(SolidStroke);
1227     context.setStrokeThickness(1.0f);
1228     context.setFillColor(color);
1229
1230     EListStyleType type = style().listStyleType();
1231     switch (type) {
1232         case Disc:
1233             context.drawEllipse(markerRect);
1234             return;
1235         case Circle:
1236             context.setFillColor(Color::transparent);
1237             context.drawEllipse(markerRect);
1238             return;
1239         case Square:
1240             context.drawRect(markerRect);
1241             return;
1242         case NoneListStyle:
1243             return;
1244         case Afar:
1245         case Amharic:
1246         case AmharicAbegede:
1247         case ArabicIndic:
1248         case Armenian:
1249         case BinaryListStyle:
1250         case Bengali:
1251         case Cambodian:
1252         case CJKIdeographic:
1253         case CjkEarthlyBranch:
1254         case CjkHeavenlyStem:
1255         case DecimalLeadingZero:
1256         case DecimalListStyle:
1257         case Devanagari:
1258         case Ethiopic:
1259         case EthiopicAbegede:
1260         case EthiopicAbegedeAmEt:
1261         case EthiopicAbegedeGez:
1262         case EthiopicAbegedeTiEr:
1263         case EthiopicAbegedeTiEt:
1264         case EthiopicHalehameAaEr:
1265         case EthiopicHalehameAaEt:
1266         case EthiopicHalehameAmEt:
1267         case EthiopicHalehameGez:
1268         case EthiopicHalehameOmEt:
1269         case EthiopicHalehameSidEt:
1270         case EthiopicHalehameSoEt:
1271         case EthiopicHalehameTiEr:
1272         case EthiopicHalehameTiEt:
1273         case EthiopicHalehameTig:
1274         case Georgian:
1275         case Gujarati:
1276         case Gurmukhi:
1277         case Hangul:
1278         case HangulConsonant:
1279         case Hebrew:
1280         case Hiragana:
1281         case HiraganaIroha:
1282         case Kannada:
1283         case Katakana:
1284         case KatakanaIroha:
1285         case Khmer:
1286         case Lao:
1287         case LowerAlpha:
1288         case LowerArmenian:
1289         case LowerGreek:
1290         case LowerHexadecimal:
1291         case LowerLatin:
1292         case LowerNorwegian:
1293         case LowerRoman:
1294         case Malayalam:
1295         case Mongolian:
1296         case Myanmar:
1297         case Octal:
1298         case Oriya:
1299         case Oromo:
1300         case Persian:
1301         case Sidama:
1302         case Somali:
1303         case Telugu:
1304         case Thai:
1305         case Tibetan:
1306         case Tigre:
1307         case TigrinyaEr:
1308         case TigrinyaErAbegede:
1309         case TigrinyaEt:
1310         case TigrinyaEtAbegede:
1311         case UpperAlpha:
1312         case UpperArmenian:
1313         case UpperGreek:
1314         case UpperHexadecimal:
1315         case UpperLatin:
1316         case UpperNorwegian:
1317         case UpperRoman:
1318         case Urdu:
1319         case Asterisks:
1320         case Footnotes:
1321             break;
1322     }
1323     if (m_text.isEmpty())
1324         return;
1325
1326     const FontCascade& font = style().fontCascade();
1327     TextRun textRun = RenderBlock::constructTextRun(m_text, style());
1328
1329     GraphicsContextStateSaver stateSaver(context, false);
1330     if (!style().isHorizontalWritingMode()) {
1331         markerRect.moveBy(-boxOrigin);
1332         markerRect = markerRect.transposedRect();
1333         markerRect.moveBy(FloatPoint(box.x(), box.y() - logicalHeight()));
1334         stateSaver.save();
1335         context.translate(markerRect.x(), markerRect.maxY());
1336         context.rotate(static_cast<float>(deg2rad(90.)));
1337         context.translate(-markerRect.x(), -markerRect.maxY());
1338     }
1339
1340     FloatPoint textOrigin = FloatPoint(markerRect.x(), markerRect.y() + style().fontMetrics().ascent());
1341     textOrigin = roundPointToDevicePixels(LayoutPoint(textOrigin), document().deviceScaleFactor(), style().isLeftToRightDirection());
1342
1343     if (type == Asterisks || type == Footnotes)
1344         context.drawText(font, textRun, textOrigin);
1345     else {
1346         const UChar suffix = listMarkerSuffix(type, m_listItem.value());
1347
1348         // Text is not arbitrary. We can judge whether it's RTL from the first character,
1349         // and we only need to handle the direction U_RIGHT_TO_LEFT for now.
1350         bool textNeedsReversing = u_charDirection(m_text[0]) == U_RIGHT_TO_LEFT;
1351         String toDraw;
1352         if (textNeedsReversing) {
1353             unsigned length = m_text.length();
1354             StringBuilder buffer;
1355             buffer.reserveCapacity(length + 2);
1356             if (!style().isLeftToRightDirection()) {
1357                 buffer.append(space);
1358                 buffer.append(suffix);
1359             }
1360             for (unsigned i = 0; i < length; ++i)
1361                 buffer.append(m_text[length - i - 1]);
1362             if (style().isLeftToRightDirection()) {
1363                 buffer.append(suffix);
1364                 buffer.append(space);
1365             }
1366             toDraw = buffer.toString();
1367         } else {
1368             if (style().isLeftToRightDirection())
1369                 toDraw = m_text + String(&suffix, 1) + String(&space, 1);
1370             else
1371                 toDraw = String(&space, 1) + String(&suffix, 1) + m_text;
1372         }
1373         textRun.setText(StringView(toDraw));
1374
1375         context.drawText(font, textRun, textOrigin);
1376     }
1377 }
1378
1379 void RenderListMarker::layout()
1380 {
1381     StackStats::LayoutCheckPoint layoutCheckPoint;
1382     ASSERT(needsLayout());
1383
1384     LayoutUnit blockOffset;
1385     for (auto* ancestor = parentBox(); ancestor && ancestor != &m_listItem; ancestor = ancestor->parentBox())
1386         blockOffset += ancestor->logicalTop();
1387     if (style().isLeftToRightDirection())
1388         m_lineOffsetForListItem = m_listItem.logicalLeftOffsetForLine(blockOffset, DoNotIndentText, LayoutUnit());
1389     else
1390         m_lineOffsetForListItem = m_listItem.logicalRightOffsetForLine(blockOffset, DoNotIndentText, LayoutUnit());
1391  
1392     if (isImage()) {
1393         updateMarginsAndContent();
1394         setWidth(m_image->imageSize(this, style().effectiveZoom()).width());
1395         setHeight(m_image->imageSize(this, style().effectiveZoom()).height());
1396     } else {
1397         setLogicalWidth(minPreferredLogicalWidth());
1398         setLogicalHeight(style().fontMetrics().height());
1399     }
1400
1401     setMarginStart(0);
1402     setMarginEnd(0);
1403
1404     Length startMargin = style().marginStart();
1405     Length endMargin = style().marginEnd();
1406     if (startMargin.isFixed())
1407         setMarginStart(startMargin.value());
1408     if (endMargin.isFixed())
1409         setMarginEnd(endMargin.value());
1410
1411     clearNeedsLayout();
1412 }
1413
1414 void RenderListMarker::imageChanged(WrappedImagePtr o, const IntRect*)
1415 {
1416     // A list marker can't have a background or border image, so no need to call the base class method.
1417     if (o != m_image->data())
1418         return;
1419
1420     if (width() != m_image->imageSize(this, style().effectiveZoom()).width() || height() != m_image->imageSize(this, style().effectiveZoom()).height() || m_image->errorOccurred())
1421         setNeedsLayoutAndPrefWidthsRecalc();
1422     else
1423         repaint();
1424 }
1425
1426 void RenderListMarker::updateMarginsAndContent()
1427 {
1428     updateContent();
1429     updateMargins();
1430 }
1431
1432 void RenderListMarker::updateContent()
1433 {
1434     // FIXME: This if-statement is just a performance optimization, but it's messy to use the preferredLogicalWidths dirty bit for this.
1435     // It's unclear if this is a premature optimization.
1436     if (!preferredLogicalWidthsDirty())
1437         return;
1438
1439     m_text = emptyString();
1440
1441     if (isImage()) {
1442         // FIXME: This is a somewhat arbitrary width.  Generated images for markers really won't become particularly useful
1443         // until we support the CSS3 marker pseudoclass to allow control over the width and height of the marker box.
1444         LayoutUnit bulletWidth = style().fontMetrics().ascent() / LayoutUnit(2);
1445         LayoutSize defaultBulletSize(bulletWidth, bulletWidth);
1446         LayoutSize imageSize = calculateImageIntrinsicDimensions(m_image.get(), defaultBulletSize, DoNotScaleByEffectiveZoom);
1447         m_image->setContainerContextForRenderer(*this, imageSize, style().effectiveZoom());
1448         return;
1449     }
1450
1451     EListStyleType type = style().listStyleType();
1452     switch (type) {
1453     case NoneListStyle:
1454         break;
1455     case Circle:
1456     case Disc:
1457     case Square:
1458         m_text = listMarkerText(type, 0); // value is ignored for these types
1459         break;
1460     case Asterisks:
1461     case Footnotes:
1462     case Afar:
1463     case Amharic:
1464     case AmharicAbegede:
1465     case ArabicIndic:
1466     case Armenian:
1467     case BinaryListStyle:
1468     case Bengali:
1469     case Cambodian:
1470     case CJKIdeographic:
1471     case CjkEarthlyBranch:
1472     case CjkHeavenlyStem:
1473     case DecimalLeadingZero:
1474     case DecimalListStyle:
1475     case Devanagari:
1476     case Ethiopic:
1477     case EthiopicAbegede:
1478     case EthiopicAbegedeAmEt:
1479     case EthiopicAbegedeGez:
1480     case EthiopicAbegedeTiEr:
1481     case EthiopicAbegedeTiEt:
1482     case EthiopicHalehameAaEr:
1483     case EthiopicHalehameAaEt:
1484     case EthiopicHalehameAmEt:
1485     case EthiopicHalehameGez:
1486     case EthiopicHalehameOmEt:
1487     case EthiopicHalehameSidEt:
1488     case EthiopicHalehameSoEt:
1489     case EthiopicHalehameTiEr:
1490     case EthiopicHalehameTiEt:
1491     case EthiopicHalehameTig:
1492     case Georgian:
1493     case Gujarati:
1494     case Gurmukhi:
1495     case Hangul:
1496     case HangulConsonant:
1497     case Hebrew:
1498     case Hiragana:
1499     case HiraganaIroha:
1500     case Kannada:
1501     case Katakana:
1502     case KatakanaIroha:
1503     case Khmer:
1504     case Lao:
1505     case LowerAlpha:
1506     case LowerArmenian:
1507     case LowerGreek:
1508     case LowerHexadecimal:
1509     case LowerLatin:
1510     case LowerNorwegian:
1511     case LowerRoman:
1512     case Malayalam:
1513     case Mongolian:
1514     case Myanmar:
1515     case Octal:
1516     case Oriya:
1517     case Oromo:
1518     case Persian:
1519     case Sidama:
1520     case Somali:
1521     case Telugu:
1522     case Thai:
1523     case Tibetan:
1524     case Tigre:
1525     case TigrinyaEr:
1526     case TigrinyaErAbegede:
1527     case TigrinyaEt:
1528     case TigrinyaEtAbegede:
1529     case UpperAlpha:
1530     case UpperArmenian:
1531     case UpperGreek:
1532     case UpperHexadecimal:
1533     case UpperLatin:
1534     case UpperNorwegian:
1535     case UpperRoman:
1536     case Urdu:
1537         m_text = listMarkerText(type, m_listItem.value());
1538         break;
1539     }
1540 }
1541
1542 void RenderListMarker::computePreferredLogicalWidths()
1543 {
1544     ASSERT(preferredLogicalWidthsDirty());
1545     updateContent();
1546
1547     if (isImage()) {
1548         LayoutSize imageSize = LayoutSize(m_image->imageSize(this, style().effectiveZoom()));
1549         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = style().isHorizontalWritingMode() ? imageSize.width() : imageSize.height();
1550         setPreferredLogicalWidthsDirty(false);
1551         updateMargins();
1552         return;
1553     }
1554
1555     const FontCascade& font = style().fontCascade();
1556
1557     LayoutUnit logicalWidth = 0;
1558     EListStyleType type = style().listStyleType();
1559     switch (type) {
1560         case NoneListStyle:
1561             break;
1562         case Asterisks:
1563         case Footnotes: {
1564             TextRun run = RenderBlock::constructTextRun(m_text, style());
1565             logicalWidth = font.width(run); // no suffix for these types
1566         }
1567             break;
1568         case Circle:
1569         case Disc:
1570         case Square:
1571             logicalWidth = (font.fontMetrics().ascent() * 2 / 3 + 1) / 2 + 2;
1572             break;
1573         case Afar:
1574         case Amharic:
1575         case AmharicAbegede:
1576         case ArabicIndic:
1577         case Armenian:
1578         case BinaryListStyle:
1579         case Bengali:
1580         case Cambodian:
1581         case CJKIdeographic:
1582         case CjkEarthlyBranch:
1583         case CjkHeavenlyStem:
1584         case DecimalLeadingZero:
1585         case DecimalListStyle:
1586         case Devanagari:
1587         case Ethiopic:
1588         case EthiopicAbegede:
1589         case EthiopicAbegedeAmEt:
1590         case EthiopicAbegedeGez:
1591         case EthiopicAbegedeTiEr:
1592         case EthiopicAbegedeTiEt:
1593         case EthiopicHalehameAaEr:
1594         case EthiopicHalehameAaEt:
1595         case EthiopicHalehameAmEt:
1596         case EthiopicHalehameGez:
1597         case EthiopicHalehameOmEt:
1598         case EthiopicHalehameSidEt:
1599         case EthiopicHalehameSoEt:
1600         case EthiopicHalehameTiEr:
1601         case EthiopicHalehameTiEt:
1602         case EthiopicHalehameTig:
1603         case Georgian:
1604         case Gujarati:
1605         case Gurmukhi:
1606         case Hangul:
1607         case HangulConsonant:
1608         case Hebrew:
1609         case Hiragana:
1610         case HiraganaIroha:
1611         case Kannada:
1612         case Katakana:
1613         case KatakanaIroha:
1614         case Khmer:
1615         case Lao:
1616         case LowerAlpha:
1617         case LowerArmenian:
1618         case LowerGreek:
1619         case LowerHexadecimal:
1620         case LowerLatin:
1621         case LowerNorwegian:
1622         case LowerRoman:
1623         case Malayalam:
1624         case Mongolian:
1625         case Myanmar:
1626         case Octal:
1627         case Oriya:
1628         case Oromo:
1629         case Persian:
1630         case Sidama:
1631         case Somali:
1632         case Telugu:
1633         case Thai:
1634         case Tibetan:
1635         case Tigre:
1636         case TigrinyaEr:
1637         case TigrinyaErAbegede:
1638         case TigrinyaEt:
1639         case TigrinyaEtAbegede:
1640         case UpperAlpha:
1641         case UpperArmenian:
1642         case UpperGreek:
1643         case UpperHexadecimal:
1644         case UpperLatin:
1645         case UpperNorwegian:
1646         case UpperRoman:
1647         case Urdu:
1648             if (m_text.isEmpty())
1649                 logicalWidth = 0;
1650             else {
1651                 TextRun run = RenderBlock::constructTextRun(m_text, style());
1652                 LayoutUnit itemWidth = font.width(run);
1653                 UChar suffixSpace[2] = { listMarkerSuffix(type, m_listItem.value()), ' ' };
1654                 LayoutUnit suffixSpaceWidth = font.width(RenderBlock::constructTextRun(suffixSpace, 2, style()));
1655                 logicalWidth = itemWidth + suffixSpaceWidth;
1656             }
1657             break;
1658     }
1659
1660     m_minPreferredLogicalWidth = logicalWidth;
1661     m_maxPreferredLogicalWidth = logicalWidth;
1662
1663     setPreferredLogicalWidthsDirty(false);
1664
1665     updateMargins();
1666 }
1667
1668 void RenderListMarker::updateMargins()
1669 {
1670     const FontMetrics& fontMetrics = style().fontMetrics();
1671
1672     LayoutUnit marginStart = 0;
1673     LayoutUnit marginEnd = 0;
1674
1675     if (isInside()) {
1676         if (isImage())
1677             marginEnd = cMarkerPadding;
1678         else switch (style().listStyleType()) {
1679             case Disc:
1680             case Circle:
1681             case Square:
1682                 marginStart = -1;
1683                 marginEnd = fontMetrics.ascent() - minPreferredLogicalWidth() + 1;
1684                 break;
1685             default:
1686                 break;
1687         }
1688     } else {
1689         if (style().isLeftToRightDirection()) {
1690             if (isImage())
1691                 marginStart = -minPreferredLogicalWidth() - cMarkerPadding;
1692             else {
1693                 int offset = fontMetrics.ascent() * 2 / 3;
1694                 switch (style().listStyleType()) {
1695                     case Disc:
1696                     case Circle:
1697                     case Square:
1698                         marginStart = -offset - cMarkerPadding - 1;
1699                         break;
1700                     case NoneListStyle:
1701                         break;
1702                     default:
1703                         marginStart = m_text.isEmpty() ? LayoutUnit() : -minPreferredLogicalWidth() - offset / 2;
1704                 }
1705             }
1706             marginEnd = -marginStart - minPreferredLogicalWidth();
1707         } else {
1708             if (isImage())
1709                 marginEnd = cMarkerPadding;
1710             else {
1711                 int offset = fontMetrics.ascent() * 2 / 3;
1712                 switch (style().listStyleType()) {
1713                     case Disc:
1714                     case Circle:
1715                     case Square:
1716                         marginEnd = offset + cMarkerPadding + 1 - minPreferredLogicalWidth();
1717                         break;
1718                     case NoneListStyle:
1719                         break;
1720                     default:
1721                         marginEnd = m_text.isEmpty() ? 0 : offset / 2;
1722                 }
1723             }
1724             marginStart = -marginEnd - minPreferredLogicalWidth();
1725         }
1726         
1727     }
1728
1729     mutableStyle().setMarginStart(Length(marginStart, Fixed));
1730     mutableStyle().setMarginEnd(Length(marginEnd, Fixed));
1731 }
1732
1733 LayoutUnit RenderListMarker::lineHeight(bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const
1734 {
1735     if (!isImage())
1736         return m_listItem.lineHeight(firstLine, direction, PositionOfInteriorLineBoxes);
1737     return RenderBox::lineHeight(firstLine, direction, linePositionMode);
1738 }
1739
1740 int RenderListMarker::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const
1741 {
1742     if (!isImage())
1743         return m_listItem.baselinePosition(baselineType, firstLine, direction, PositionOfInteriorLineBoxes);
1744     return RenderBox::baselinePosition(baselineType, firstLine, direction, linePositionMode);
1745 }
1746
1747 String RenderListMarker::suffix() const
1748 {
1749     EListStyleType type = style().listStyleType();
1750     const UChar suffix = listMarkerSuffix(type, m_listItem.value());
1751
1752     if (suffix == ' ')
1753         return String(" ");
1754
1755     // If the suffix is not ' ', an extra space is needed
1756     UChar data[2];
1757     if (style().isLeftToRightDirection()) {
1758         data[0] = suffix;
1759         data[1] = ' ';
1760     } else {
1761         data[0] = ' ';
1762         data[1] = suffix;
1763     }
1764
1765     return String(data, 2);
1766 }
1767
1768 bool RenderListMarker::isInside() const
1769 {
1770     return m_listItem.notInList() || style().listStylePosition() == INSIDE;
1771 }
1772
1773 FloatRect RenderListMarker::getRelativeMarkerRect()
1774 {
1775     if (isImage())
1776         return FloatRect(0, 0, m_image->imageSize(this, style().effectiveZoom()).width(), m_image->imageSize(this, style().effectiveZoom()).height());
1777     
1778     FloatRect relativeRect;
1779     EListStyleType type = style().listStyleType();
1780     switch (type) {
1781         case Asterisks:
1782         case Footnotes: {
1783             const FontCascade& font = style().fontCascade();
1784             TextRun run = RenderBlock::constructTextRun(m_text, style());
1785             relativeRect = FloatRect(0, 0, font.width(run), font.fontMetrics().height());
1786             break;
1787         }
1788         case Disc:
1789         case Circle:
1790         case Square: {
1791             // FIXME: Are these particular rounding rules necessary?
1792             const FontMetrics& fontMetrics = style().fontMetrics();
1793             int ascent = fontMetrics.ascent();
1794             int bulletWidth = (ascent * 2 / 3 + 1) / 2;
1795             relativeRect = FloatRect(1, 3 * (ascent - ascent * 2 / 3) / 2, bulletWidth, bulletWidth);
1796             break;
1797         }
1798         case NoneListStyle:
1799             return FloatRect();
1800         case Afar:
1801         case Amharic:
1802         case AmharicAbegede:
1803         case ArabicIndic:
1804         case Armenian:
1805         case BinaryListStyle:
1806         case Bengali:
1807         case Cambodian:
1808         case CJKIdeographic:
1809         case CjkEarthlyBranch:
1810         case CjkHeavenlyStem:
1811         case DecimalLeadingZero:
1812         case DecimalListStyle:
1813         case Devanagari:
1814         case Ethiopic:
1815         case EthiopicAbegede:
1816         case EthiopicAbegedeAmEt:
1817         case EthiopicAbegedeGez:
1818         case EthiopicAbegedeTiEr:
1819         case EthiopicAbegedeTiEt:
1820         case EthiopicHalehameAaEr:
1821         case EthiopicHalehameAaEt:
1822         case EthiopicHalehameAmEt:
1823         case EthiopicHalehameGez:
1824         case EthiopicHalehameOmEt:
1825         case EthiopicHalehameSidEt:
1826         case EthiopicHalehameSoEt:
1827         case EthiopicHalehameTiEr:
1828         case EthiopicHalehameTiEt:
1829         case EthiopicHalehameTig:
1830         case Georgian:
1831         case Gujarati:
1832         case Gurmukhi:
1833         case Hangul:
1834         case HangulConsonant:
1835         case Hebrew:
1836         case Hiragana:
1837         case HiraganaIroha:
1838         case Kannada:
1839         case Katakana:
1840         case KatakanaIroha:
1841         case Khmer:
1842         case Lao:
1843         case LowerAlpha:
1844         case LowerArmenian:
1845         case LowerGreek:
1846         case LowerHexadecimal:
1847         case LowerLatin:
1848         case LowerNorwegian:
1849         case LowerRoman:
1850         case Malayalam:
1851         case Mongolian:
1852         case Myanmar:
1853         case Octal:
1854         case Oriya:
1855         case Oromo:
1856         case Persian:
1857         case Sidama:
1858         case Somali:
1859         case Telugu:
1860         case Thai:
1861         case Tibetan:
1862         case Tigre:
1863         case TigrinyaEr:
1864         case TigrinyaErAbegede:
1865         case TigrinyaEt:
1866         case TigrinyaEtAbegede:
1867         case UpperAlpha:
1868         case UpperArmenian:
1869         case UpperGreek:
1870         case UpperHexadecimal:
1871         case UpperLatin:
1872         case UpperNorwegian:
1873         case UpperRoman:
1874         case Urdu:
1875             if (m_text.isEmpty())
1876                 return FloatRect();
1877             const FontCascade& font = style().fontCascade();
1878             TextRun run = RenderBlock::constructTextRun(m_text, style());
1879             float itemWidth = font.width(run);
1880             UChar suffixSpace[2] = { listMarkerSuffix(type, m_listItem.value()), ' ' };
1881             float suffixSpaceWidth = font.width(RenderBlock::constructTextRun(suffixSpace, 2, style()));
1882             relativeRect = FloatRect(0, 0, itemWidth + suffixSpaceWidth, font.fontMetrics().height());
1883     }
1884
1885     if (!style().isHorizontalWritingMode()) {
1886         relativeRect = relativeRect.transposedRect();
1887         relativeRect.setX(width() - relativeRect.x() - relativeRect.width());
1888     }
1889
1890     return relativeRect;
1891 }
1892
1893 void RenderListMarker::setSelectionState(SelectionState state)
1894 {
1895     // The selection state for our containing block hierarchy is updated by the base class call.
1896     RenderBox::setSelectionState(state);
1897
1898     if (m_inlineBoxWrapper && canUpdateSelectionOnRootLineBoxes())
1899         m_inlineBoxWrapper->root().setHasSelectedChildren(state != SelectionNone);
1900 }
1901
1902 LayoutRect RenderListMarker::selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool clipToVisibleContent)
1903 {
1904     ASSERT(!needsLayout());
1905
1906     if (selectionState() == SelectionNone || !inlineBoxWrapper())
1907         return LayoutRect();
1908
1909     RootInlineBox& rootBox = inlineBoxWrapper()->root();
1910     LayoutRect rect(0, rootBox.selectionTop() - y(), width(), rootBox.selectionHeight());
1911             
1912     if (clipToVisibleContent)
1913         return computeRectForRepaint(rect, repaintContainer);
1914     return localToContainerQuad(FloatRect(rect), repaintContainer).enclosingBoundingBox();
1915 }
1916
1917 } // namespace WebCore