File: src\Framework\MS\Internal\PtsHost\ListMarkerSourceInfo.cs
Project: wpf\PresentationFramework.csproj (PresentationFramework)
//---------------------------------------------------------------------------
//
// Copyright (C) Microsoft Corporation.  All rights reserved.
// 
// File: ListMarkerSourceInfo.cs
//
// Information about list markers for different types of list. 
// NOTE: This logic depends on the logic used in MS.Internal.TextFormatting.TextMarkerSource.cs 
// This file must always be kept up to date with changes in TextMarkerSource
//
//---------------------------------------------------------------------------
 
using System;
using System.Diagnostics;
using System.Windows;
using System.Windows.Documents;   // List
using MS.Internal.Text;             
using System.Windows.Media;       // FormattedText and Brush
using MS.Internal.TextFormatting; // TextMarkerSource
using System.Text;                // StringBuilder
 
namespace MS.Internal.PtsHost
{
    /// <summary>
    /// ListMarkerSourceInfo contains information about list markers for different types of lists
    /// </summary>
    internal sealed class ListMarkerSourceInfo
    {
        /// <summary>
        /// Private constructor to prevent the compiler from generating a default constructor. 
        /// </summary>
        private ListMarkerSourceInfo()
        {
        }
 
        /// <summary>
        /// Calculate padding for a list
        /// </summary>
        /// <param name="list">
        /// Specified List element 
        /// </param>
        /// <param name="lineHeight">
        /// Line height for list element
        /// </param>
        internal static Thickness CalculatePadding(List list, double lineHeight, double pixelsPerDip)
        {
            FormattedText formattedMarker = GetFormattedMarker(list, pixelsPerDip);
            double leftPadding = formattedMarker.Width + 1.5 * lineHeight;
            leftPadding = (double)((int)(leftPadding / lineHeight) + 1) * lineHeight;
            return new Thickness(leftPadding, 0, 0, 0);
        }
 
        /// <summary>
        /// Returns FormattedText for the largets marker in a list
        /// </summary>
        /// <param name="list">
        /// List element for which formatted marker is to be calculated
        /// </param>
        private static FormattedText GetFormattedMarker(List list, double pixelsPerDip)
        {
            string markerString = "";
            FormattedText formattedMarker;
 
            if (IsKnownSymbolMarkerStyle(list.MarkerStyle))
            {
                switch (list.MarkerStyle)
                {
                    case TextMarkerStyle.Disc:
                        markerString = "\x9f";
                        break;
 
                    case TextMarkerStyle.Circle:
                        markerString = "\xa1";
                        break;
 
                    case TextMarkerStyle.Square:
                        markerString = "\x71";
                        break;
 
                    case TextMarkerStyle.Box:
                        markerString = "\xa7";
                        break;
                }
 
                // Create new formatted text with typeface using a symbol font, e.g. Wingdings
                Typeface typeface = DynamicPropertyReader.GetModifiedTypeface(list, new FontFamily("Wingdings"));
                
                formattedMarker = new FormattedText(markerString, DynamicPropertyReader.GetCultureInfo(list), list.FlowDirection,
                                      typeface, list.FontSize, list.Foreground, pixelsPerDip);
 
            }
            else if (IsKnownIndexMarkerStyle(list.MarkerStyle))
            {
                // Assume at least one element will be added and format accordingly
                int startIndex = list.StartIndex;
                Invariant.Assert(startIndex > 0);
                int size = list.ListItems.Count;
                int highestIndex;
                if (int.MaxValue - size < startIndex)
                {
                    // Highest index will exceed max value of int. Clamp to int.MaxValue
                    highestIndex = int.MaxValue;
                }
                else
                {
                    highestIndex = (size == 0) ? startIndex : startIndex + size - 1;
                }
                switch (list.MarkerStyle)
                {
                    case TextMarkerStyle.Decimal:
                        markerString = ConvertNumberToString(highestIndex, false, DecimalNumerics);
                        break;
 
                    case TextMarkerStyle.LowerLatin:
                        markerString = ConvertNumberToString(highestIndex, true, LowerLatinNumerics);
                        break;
 
                    case TextMarkerStyle.UpperLatin:
                        markerString = ConvertNumberToString(highestIndex, true, UpperLatinNumerics);
                        break;
 
                    case TextMarkerStyle.LowerRoman:
                        markerString = GetStringForLargestRomanMarker(startIndex, highestIndex, false);
                        break;
 
                    case TextMarkerStyle.UpperRoman:
                        markerString = GetStringForLargestRomanMarker(startIndex, highestIndex, true);
                        break;
                }
 
                // Create new formatted text using List defaulls                
                formattedMarker = new FormattedText(markerString, DynamicPropertyReader.GetCultureInfo(list), list.FlowDirection,
                                      DynamicPropertyReader.GetTypeface(list), list.FontSize, list.Foreground, pixelsPerDip);
            }
            else
            {
                // Assume a disc
                markerString = "\x9f";
                // Create new formatted text with typeface using a symbol font, e.g. Wingdings
                Typeface typeface = DynamicPropertyReader.GetModifiedTypeface(list, new FontFamily("Wingdings"));
 
                formattedMarker = new FormattedText(markerString, DynamicPropertyReader.GetCultureInfo(list), list.FlowDirection,
                                      typeface, list.FontSize, list.Foreground, pixelsPerDip);
            }
            return formattedMarker;
        }
 
        /// <summary>
        /// Convert a number to string, consisting of digits followed by the NumberSuffix character.
        /// From TextMarkerSource, uses same conversion
        /// </summary>
        /// <param name="number">Number to convert.</param>
        /// <param name="oneBased">True if there is no zero digit (e.g., alpha numbering).</param>
        /// <param name="numericSymbols">Set of digits (e.g., 0-9 or a-z).</param>
        /// <returns>Returns the number string as an array of characters.</returns>
        private static string ConvertNumberToString(int number, bool oneBased, string numericSymbols)
        {
            if (oneBased)
            {
                // Subtract 1 from 1-based numbers so we can use zero-based indexing
                --number;
            }
 
            Invariant.Assert(number >= 0);
 
            char[] result;
            int b = numericSymbols.Length;
            if (number < b)
            {
                // Optimize common case of single-digit numbers.
                // Optimize common case of single-digit numbers.
                result = new char[2]; // digit + suffix
                result[0] = numericSymbols[number];
                result[1] = NumberSuffix;
            }
            else
            {
                // Disjoint is 1 if and only if the set of numbers with N
                // digits and the set of numbers with (N+1) digits are
                // disjoint (see comment above). Otherwise it is zero.
                int disjoint = oneBased ? 1 : 0;
 
                // Count digits. We stop when the limit (i.e., 1 + the max value 
                // for the current number of digits) exceeds the specified number.
                int digits = 1;
                for (long limit = b, pow = b; (long)number >= limit; ++digits)
                {
                    // Neither of the following calculations can overflow because
                    // we know both pow and limit are <= number (which is an int)
                    // and b is at most 26.
                    pow *= b;
                    limit = pow + (limit * disjoint);
                }
 
                // Build string in reverse order starting with suffix.
                // Build string in reverse order starting with suffix.
                result = new char[digits + 1]; // digits + suffix
                result[digits] = NumberSuffix;
                for (int i = digits - 1; i >= 0; --i)
                {
                    result[i] = numericSymbols[number % b];
                    number = (number / b) - disjoint;
                }
            }
 
            return new string(result);
        }
 
        /// <summary>
        /// Returns string for the largest roman marker in a list with Roman numbering style
        /// </summary>
        /// <param name="startIndex">
        /// Start index of list
        /// </param>
        /// <param name="highestIndex">
        /// Number of elements in the list
        /// </param>
        /// <param name="uppercase">
        /// True if list uses uppercase mode
        /// </param>
        private static string GetStringForLargestRomanMarker(int startIndex, int highestIndex, bool uppercase)
        {
            int largestMarkerIndex = 0;
            if (highestIndex > 3999)
            {
                // Roman numerals are 1-based and there is no accepted convention
                // for writing numbers larger than 3999. For anything larger than this,
                // we assume the largest value under 3999, which is 3888 or
                // MMMDCCCLXXXVIII. TextSourceMarker willnot support larger values anyway.
                return uppercase ? LargestRomanMarkerUpper : LargestRomanMarkerLower;
            }
            else
            {
                largestMarkerIndex = GetIndexForLargestRomanMarker(startIndex, highestIndex);
            }
            return ConvertNumberToRomanString(largestMarkerIndex, uppercase);
        }
 
        /// <summary>
        /// Returns the index of the roman marker that will have largest width, i.e. most letters
        /// </summary>
        /// <param name="startIndex">
        /// Start index of the list
        /// </param>
        /// <param name="highestIndex">
        /// Highest-numbered index in the list
        /// </param>
        private static int GetIndexForLargestRomanMarker(int startIndex, int highestIndex)
        {
            int largestIndex = 0;
 
            if (startIndex == 1)
            {
                // Do quick search by looking only at size increments
                int thousands = highestIndex / 1000;
                highestIndex = highestIndex % 1000;            
                for (int i = 0; i < RomanNumericSizeIncrements.Length; i++)
                {
                    Invariant.Assert(highestIndex >= RomanNumericSizeIncrements[i]);
                    if (highestIndex == RomanNumericSizeIncrements[i])
                    {
                        // This is the largest index. 
                        largestIndex = highestIndex;
                        break;
                    }
                    else
                    {
 
                        Invariant.Assert(highestIndex > RomanNumericSizeIncrements[i]);
                        if (i < RomanNumericSizeIncrements.Length - 1)
                        {
                            if (highestIndex >= RomanNumericSizeIncrements[i + 1])
                            {
                                // Size does not lie within this increment range. Keep searching
                                continue;
                            }
                        }
 
                        // Size is either larger than the largest increment value,
                        // or lies between two increment values in which case we
                        // take the lower one
                        largestIndex = RomanNumericSizeIncrements[i];
                        break;
                    }
                }
                if (thousands > 0)
                {
                    // M's will be added to largest index for extra thousands
                    largestIndex = thousands * 1000 + largestIndex;
                }
            }
            else
            {
                // Quick search will not work. Look at each index
                int largestIndexSize = 0;
                for (int i = startIndex; i <= highestIndex; i++)
                {
                    // Format as roman string. It does not matter if we use upper or lowercase formatting here since 
                    // we are only counting number of letters in each string. This is not strictly correct - 
                    // III might be smaller than XX in some fonts - but we cannot format text each time.
                    string romanString = ConvertNumberToRomanString(i, true);
                    if (romanString.Length > largestIndexSize)
                    {
                        largestIndex = i;
                        largestIndexSize = romanString.Length;
                    }
                }
            }
 
            Invariant.Assert(largestIndex > 0);
            return largestIndex;
        }
 
        /// <summary>
        /// Convert 1-based number to a Roman numeric string
        /// followed by NumberSuffix character.
        /// </summary>
        private static string ConvertNumberToRomanString(
            int number,
            bool uppercase)
        {
            Invariant.Assert(number <= 3999);
 
            StringBuilder builder = new StringBuilder();
 
            AddRomanNumeric(builder, number / 1000, RomanNumerics[uppercase ? 1 : 0][0]);
            number %= 1000;
            AddRomanNumeric(builder, number / 100, RomanNumerics[uppercase ? 1 : 0][1]);
            number %= 100;
            AddRomanNumeric(builder, number / 10, RomanNumerics[uppercase ? 1 : 0][2]);
            number %= 10;
            AddRomanNumeric(builder, number, RomanNumerics[uppercase ? 1 : 0][3]);
 
            builder.Append(NumberSuffix);
            return builder.ToString();
        }
 
        /// <summary>
        /// Convert number 0 - 9 into Roman numeric. From TextMarkerSource
        /// </summary>
        /// <param name="builder">string builder</param>
        /// <param name="number">number to convert</param>
        /// <param name="oneFiveTen">Roman numeric char for one five and ten</param>
        private static void AddRomanNumeric(
            StringBuilder builder,
            int number,
            string oneFiveTen)
        {
            Debug.Assert(number >= 0 && number <= 9);
 
            if (number >= 1 && number <= 9)
            {
                if (number == 4 || number == 9)
                    builder.Append(oneFiveTen[0]);
 
                if (number == 9)
                {
                    builder.Append(oneFiveTen[2]);
                }
                else
                {
                    if (number >= 4)
                        builder.Append(oneFiveTen[1]);
 
                    for (int i = number % 5; i > 0 && i < 4; i--)
                        builder.Append(oneFiveTen[0]);
                }
            }
        }
 
        private static bool IsKnownSymbolMarkerStyle(TextMarkerStyle markerStyle)
        {
            return (
                    markerStyle == TextMarkerStyle.Disc
                || markerStyle == TextMarkerStyle.Circle
                || markerStyle == TextMarkerStyle.Square
                || markerStyle == TextMarkerStyle.Box
                );
        }
 
        private static bool IsKnownIndexMarkerStyle(TextMarkerStyle markerStyle)
        {
            return (
                    markerStyle == TextMarkerStyle.Decimal
                || markerStyle == TextMarkerStyle.LowerLatin
                || markerStyle == TextMarkerStyle.UpperLatin
                || markerStyle == TextMarkerStyle.LowerRoman
                || markerStyle == TextMarkerStyle.UpperRoman
                );
        }
 
        // Const values for marker conversion
        private static char NumberSuffix = '.';
        private static string DecimalNumerics = "0123456789";
        private static string LowerLatinNumerics = "abcdefghijklmnopqrstuvwxyz";
        private static string UpperLatinNumerics = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        private static string LargestRomanMarkerUpper = "MMMDCCCLXXXVIII";
        private static string LargestRomanMarkerLower = "mmmdccclxxxviii";
 
        private static string[][] RomanNumerics = new string[][]
        {
            new string[] { "m??", "cdm", "xlc", "ivx" }, 
            new string[] { "M??", "CDM", "XLC", "IVX" }
        };
 
        private static int[] RomanNumericSizeIncrements =
            new int[] { 1, 2, 3, 8, 18, 28, 38, 88, 188, 288, 388, 888 };
 
    }
}