Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / Core / CSharp / MS / Internal / TextFormatting / TextMarkerSource.cs / 1 / TextMarkerSource.cs
//------------------------------------------------------------------------
//
// Microsoft Windows Client Platform
// Copyright (C) Microsoft Corporation, 2001
//
// File: TextMarkerSource.cs
//
// Contents: Generated content for marker symbol
//
// Created: 3-10-2003 Worachai Chaoweeraprasit (wchao)
//
//-----------------------------------------------------------------------
using System;
using System.Diagnostics;
using System.Windows.Threading;
using System.Text;
using System.Globalization;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.TextFormatting;
using MS.Internal;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace MS.Internal.TextFormatting
{
///
/// Implementation of TextSource for used by marker
///
internal sealed class TextMarkerSource : TextSource
{
private char[] _characterArray;
private TextRunProperties _textRunProperties;
private TextParagraphProperties _textParagraphProperties;
private const char NumberSuffix = '.';
private const string DecimalNumerics = "0123456789";
private const string LowerLatinNumerics = "abcdefghijklmnopqrstuvwxyz";
private const string UpperLatinNumerics = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
private static string[][] RomanNumerics = new string[][]
{
new string[] { "m??", "cdm", "xlc", "ivx" },
new string[] { "M??", "CDM", "XLC", "IVX" }
};
internal TextMarkerSource(
TextParagraphProperties textParagraphProperties,
TextMarkerStyle markerStyle,
int autoNumberingIndex
)
{
Debug.Assert(markerStyle != TextMarkerStyle.None);
_textParagraphProperties = textParagraphProperties;
TextRunProperties defaultRunProperties = _textParagraphProperties.DefaultTextRunProperties;
string symbolString = null;
if(IsKnownSymbolMarkerStyle(markerStyle))
{
switch(markerStyle)
{
case TextMarkerStyle.Disc:
symbolString = "\x9f"; break;
case TextMarkerStyle.Circle:
symbolString = "\xa1"; break;
case TextMarkerStyle.Square:
symbolString = "\x71"; break;
case TextMarkerStyle.Box:
symbolString = "\xa7"; break;
}
Typeface defaultTypeface = defaultRunProperties.Typeface;
// recreate a new marker run properties based on symbol typeface e.g. Wingding
_textRunProperties = new GenericTextRunProperties(
new Typeface(
new FontFamily("Wingdings"),
defaultTypeface.Style,
defaultTypeface.Weight,
defaultTypeface.Stretch
),
defaultRunProperties.FontRenderingEmSize,
defaultRunProperties.FontHintingEmSize,
defaultRunProperties.TextDecorations,
defaultRunProperties.ForegroundBrush,
defaultRunProperties.BackgroundBrush,
defaultRunProperties.BaselineAlignment,
CultureMapper.GetSpecificCulture(defaultRunProperties.CultureInfo),
null // default number substitution for culture
);
}
else if(IsKnownIndexMarkerStyle(markerStyle))
{
// Internal client code should have already validated this.
Debug.Assert(autoNumberingIndex > 0);
_textRunProperties = defaultRunProperties;
int counter = autoNumberingIndex;
switch(markerStyle)
{
case TextMarkerStyle.Decimal:
_characterArray = ConvertNumberToString(counter, false, DecimalNumerics);
break;
case TextMarkerStyle.LowerLatin:
_characterArray = ConvertNumberToString(counter, true, LowerLatinNumerics);
break;
case TextMarkerStyle.UpperLatin:
_characterArray = ConvertNumberToString(counter, true, UpperLatinNumerics);
break;
case TextMarkerStyle.LowerRoman:
symbolString = ConvertNumberToRomanString(counter, false);
break;
case TextMarkerStyle.UpperRoman:
symbolString = ConvertNumberToRomanString(counter, true);
break;
}
}
else
{
Debug.Assert(false, "Invalid marker style");
}
if(symbolString != null)
{
_characterArray = symbolString.ToCharArray();
}
Debug.Assert(_characterArray != null);
}
#region TextSource implementation
///
/// TextFormatter to get a text run started at specified text source position
///
public override TextRun GetTextRun(
int textSourceCharacterIndex
)
{
if (textSourceCharacterIndex < _characterArray.Length)
{
return new TextCharacters(
_characterArray,
textSourceCharacterIndex,
_characterArray.Length - textSourceCharacterIndex,
_textRunProperties
);
}
// Because LS ignores the character for TextEndOfLine characters in marker,
// We must return TextEndOfParagraph to termine fetching.
return new TextEndOfParagraph(1);
}
///
/// TextFormatter to get text immediately before specified text source position.
///
public override TextSpan GetPrecedingText(
int textSourceCharacterIndexLimit
)
{
CharacterBufferRange charString = CharacterBufferRange.Empty;
if (textSourceCharacterIndexLimit > 0)
{
charString = new CharacterBufferRange(
new CharacterBufferReference(_characterArray, 0),
Math.Min(_characterArray.Length, textSourceCharacterIndexLimit)
);
}
return new TextSpan (
textSourceCharacterIndexLimit,
new CultureSpecificCharacterBufferRange(CultureMapper.GetSpecificCulture(_textRunProperties.CultureInfo), charString)
);
}
///
/// TextFormatter to map a text source character index to a text effect character index
///
/// text source character index
/// the text effect index corresponding to the text effect character index
public override int GetTextEffectCharacterIndexFromTextSourceCharacterIndex(
int textSourceCharacterIndex
)
{
throw new NotSupportedException();
}
#endregion
///
/// Convert a number to string, consisting of digits followed by the NumberSuffix character.
///
/// Number to convert.
/// True if there is no zero digit (e.g., alpha numbering).
/// Set of digits (e.g., 0-9 or a-z).
/// Returns the number string as an array of characters.
private static char[] ConvertNumberToString(int number, bool oneBased, string numericSymbols)
{
// Whether zero-based or one-based numbering is used affects how we
// count and how we determine the maximum number of values for a
// given number of digits.
//
// The following table illustrates how counting differs. In both
// cases we're using base-2 numbering (i.e., two distinct digits),
// but with 1-based counting each of those two digits can be a
// significant leading digit.
//
// 0-based 1-based
// ----------------------------
// 0 0 --
// 1 1 a
// 2 10 b
// 3 11 aa
// 4 100 ab
// 5 101 ba
// 6 110 bb
// 7 111 aaa
// 8 1000 aab
// 9 1001 aba
// 10 1010 abb
// 11 1011 baa
// 12 1100 bab
// 13 1101 bba
// 14 1110 bbb
// 15 1111 aaaa
// 16 10000 aaab
//
// For zero-based counting, adding a leading zero does not change
// the value of a number. Thus, the set of all N-digit numbers is
// a proper subset of the set of (N+1)-digit numbers. Thus the set
// of values that can be represented by N *or fewer* digits is the
// same as the number of combinations of exactly N digits, i.e.,
//
// b ^ N
//
// where b is the base of the numbering system.
//
// For one-based counting, there is no zero digit. Thus, the set
// of N-digit numbers and the set of (N+1)-digit numbers are
// disjoint sets. Thus, while the number of combinations of
// *exactly* N digits is still b ^ N, the maximum value that
// can be represented by N *or fewer* digits is:
//
// Max(N)
// where N = 1 : b
// where N > 1 : (b ^ N) + Max(N - 1)
//
if (oneBased)
{
// Subtract 1 from 1-based numbers so we can use zero-based
// indexing. The formula for Max(N) given above should now be
// thought of as a limit rather than a maximum.
--number;
}
Debug.Assert(number >= 0);
char[] result;
int b = numericSymbols.Length;
if (number < b)
{
// 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.
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 result;
}
///
/// Convert 1-based number to a Roman numeric string
/// followed by NumberSuffix character.
///
///
/// Roman number is 1-based. The Roman numeric string is a series of symbols. Following
/// is the list of symbols and its value.
///
/// Symbol Value
/// I 1
/// V 5
/// X 10
/// L 50
/// C 100
/// D 500
/// M 1000
///
/// The rule of Roman number prohibits the use of more than 3 consecutive identical symbol
/// but using subtraction of symbol standing for multiples of 10, so the value 4 is written
/// as IV (5-1) rather than IIII.
///
/// Due to the writing rule and the fact that the symbol represents not the numeral digit
/// but the value of the number. Roman number system cannot represent value larger than 3999.
///
/// See, http://www.ccsn.nevada.edu/math/ancient_systems.htm
///
/// However, there exists a more relaxing use of Roman numbers to represent values 4000 and
/// 4999 by using 4 consecutive M. The value 4999 is than written as 'MMMMCMXCIX'. Such use
/// however is not widely accepted.
///
/// See, http://www.guernsey.net/~sgibbs/roman.html
///
/// For values larger than 3999, an overscore is used on the symbol to indicate 1000 multiplication.
/// ___
/// So, value 7000 would be written as VII. This writing rule has a fair amount of disagreement
/// since it is widely understood that it is not invented by the Romans and they rarely had a
/// need for large numbers during their time. Furthermore, accepting this writing rule just
/// for the sake of being able to write larger number would create a new limitation of the values
/// greater than 3,999,999. Unicode 4.0 does not encode these overscore symbols.
///
/// See, http://www.gwydir.demon.co.uk/jo/roman/number.htm
/// http://www.novaroma.org/via_romana/numbers.html
///
/// Implementation-wise, IE adopts a general limitation of 3999 and simply convert the value
/// into a regular numeric form.
///
/// We'll follow the mainstream and adopt the 3999 limit. The fallback would also do would IE does.
///
///
private static string ConvertNumberToRomanString(
int number,
bool uppercase
)
{
if (number > 3999)
{
// Roman numeric string not supported
return number.ToString(CultureInfo.InvariantCulture);
}
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();
}
///
/// Convert number 0 - 9 into Roman numeric
///
/// string builder
/// number to convert
/// Roman numeric char for one five and ten
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]);
}
}
}
internal static bool IsKnownSymbolMarkerStyle(TextMarkerStyle markerStyle)
{
return (
markerStyle == TextMarkerStyle.Disc
|| markerStyle == TextMarkerStyle.Circle
|| markerStyle == TextMarkerStyle.Square
|| markerStyle == TextMarkerStyle.Box
);
}
internal static bool IsKnownIndexMarkerStyle(TextMarkerStyle markerStyle)
{
return (
markerStyle == TextMarkerStyle.Decimal
|| markerStyle == TextMarkerStyle.LowerLatin
|| markerStyle == TextMarkerStyle.UpperLatin
|| markerStyle == TextMarkerStyle.LowerRoman
|| markerStyle == TextMarkerStyle.UpperRoman
);
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------
//
// Microsoft Windows Client Platform
// Copyright (C) Microsoft Corporation, 2001
//
// File: TextMarkerSource.cs
//
// Contents: Generated content for marker symbol
//
// Created: 3-10-2003 Worachai Chaoweeraprasit (wchao)
//
//-----------------------------------------------------------------------
using System;
using System.Diagnostics;
using System.Windows.Threading;
using System.Text;
using System.Globalization;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.TextFormatting;
using MS.Internal;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace MS.Internal.TextFormatting
{
///
/// Implementation of TextSource for used by marker
///
internal sealed class TextMarkerSource : TextSource
{
private char[] _characterArray;
private TextRunProperties _textRunProperties;
private TextParagraphProperties _textParagraphProperties;
private const char NumberSuffix = '.';
private const string DecimalNumerics = "0123456789";
private const string LowerLatinNumerics = "abcdefghijklmnopqrstuvwxyz";
private const string UpperLatinNumerics = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
private static string[][] RomanNumerics = new string[][]
{
new string[] { "m??", "cdm", "xlc", "ivx" },
new string[] { "M??", "CDM", "XLC", "IVX" }
};
internal TextMarkerSource(
TextParagraphProperties textParagraphProperties,
TextMarkerStyle markerStyle,
int autoNumberingIndex
)
{
Debug.Assert(markerStyle != TextMarkerStyle.None);
_textParagraphProperties = textParagraphProperties;
TextRunProperties defaultRunProperties = _textParagraphProperties.DefaultTextRunProperties;
string symbolString = null;
if(IsKnownSymbolMarkerStyle(markerStyle))
{
switch(markerStyle)
{
case TextMarkerStyle.Disc:
symbolString = "\x9f"; break;
case TextMarkerStyle.Circle:
symbolString = "\xa1"; break;
case TextMarkerStyle.Square:
symbolString = "\x71"; break;
case TextMarkerStyle.Box:
symbolString = "\xa7"; break;
}
Typeface defaultTypeface = defaultRunProperties.Typeface;
// recreate a new marker run properties based on symbol typeface e.g. Wingding
_textRunProperties = new GenericTextRunProperties(
new Typeface(
new FontFamily("Wingdings"),
defaultTypeface.Style,
defaultTypeface.Weight,
defaultTypeface.Stretch
),
defaultRunProperties.FontRenderingEmSize,
defaultRunProperties.FontHintingEmSize,
defaultRunProperties.TextDecorations,
defaultRunProperties.ForegroundBrush,
defaultRunProperties.BackgroundBrush,
defaultRunProperties.BaselineAlignment,
CultureMapper.GetSpecificCulture(defaultRunProperties.CultureInfo),
null // default number substitution for culture
);
}
else if(IsKnownIndexMarkerStyle(markerStyle))
{
// Internal client code should have already validated this.
Debug.Assert(autoNumberingIndex > 0);
_textRunProperties = defaultRunProperties;
int counter = autoNumberingIndex;
switch(markerStyle)
{
case TextMarkerStyle.Decimal:
_characterArray = ConvertNumberToString(counter, false, DecimalNumerics);
break;
case TextMarkerStyle.LowerLatin:
_characterArray = ConvertNumberToString(counter, true, LowerLatinNumerics);
break;
case TextMarkerStyle.UpperLatin:
_characterArray = ConvertNumberToString(counter, true, UpperLatinNumerics);
break;
case TextMarkerStyle.LowerRoman:
symbolString = ConvertNumberToRomanString(counter, false);
break;
case TextMarkerStyle.UpperRoman:
symbolString = ConvertNumberToRomanString(counter, true);
break;
}
}
else
{
Debug.Assert(false, "Invalid marker style");
}
if(symbolString != null)
{
_characterArray = symbolString.ToCharArray();
}
Debug.Assert(_characterArray != null);
}
#region TextSource implementation
///
/// TextFormatter to get a text run started at specified text source position
///
public override TextRun GetTextRun(
int textSourceCharacterIndex
)
{
if (textSourceCharacterIndex < _characterArray.Length)
{
return new TextCharacters(
_characterArray,
textSourceCharacterIndex,
_characterArray.Length - textSourceCharacterIndex,
_textRunProperties
);
}
// Because LS ignores the character for TextEndOfLine characters in marker,
// We must return TextEndOfParagraph to termine fetching.
return new TextEndOfParagraph(1);
}
///
/// TextFormatter to get text immediately before specified text source position.
///
public override TextSpan GetPrecedingText(
int textSourceCharacterIndexLimit
)
{
CharacterBufferRange charString = CharacterBufferRange.Empty;
if (textSourceCharacterIndexLimit > 0)
{
charString = new CharacterBufferRange(
new CharacterBufferReference(_characterArray, 0),
Math.Min(_characterArray.Length, textSourceCharacterIndexLimit)
);
}
return new TextSpan (
textSourceCharacterIndexLimit,
new CultureSpecificCharacterBufferRange(CultureMapper.GetSpecificCulture(_textRunProperties.CultureInfo), charString)
);
}
///
/// TextFormatter to map a text source character index to a text effect character index
///
/// text source character index
/// the text effect index corresponding to the text effect character index
public override int GetTextEffectCharacterIndexFromTextSourceCharacterIndex(
int textSourceCharacterIndex
)
{
throw new NotSupportedException();
}
#endregion
///
/// Convert a number to string, consisting of digits followed by the NumberSuffix character.
///
/// Number to convert.
/// True if there is no zero digit (e.g., alpha numbering).
/// Set of digits (e.g., 0-9 or a-z).
/// Returns the number string as an array of characters.
private static char[] ConvertNumberToString(int number, bool oneBased, string numericSymbols)
{
// Whether zero-based or one-based numbering is used affects how we
// count and how we determine the maximum number of values for a
// given number of digits.
//
// The following table illustrates how counting differs. In both
// cases we're using base-2 numbering (i.e., two distinct digits),
// but with 1-based counting each of those two digits can be a
// significant leading digit.
//
// 0-based 1-based
// ----------------------------
// 0 0 --
// 1 1 a
// 2 10 b
// 3 11 aa
// 4 100 ab
// 5 101 ba
// 6 110 bb
// 7 111 aaa
// 8 1000 aab
// 9 1001 aba
// 10 1010 abb
// 11 1011 baa
// 12 1100 bab
// 13 1101 bba
// 14 1110 bbb
// 15 1111 aaaa
// 16 10000 aaab
//
// For zero-based counting, adding a leading zero does not change
// the value of a number. Thus, the set of all N-digit numbers is
// a proper subset of the set of (N+1)-digit numbers. Thus the set
// of values that can be represented by N *or fewer* digits is the
// same as the number of combinations of exactly N digits, i.e.,
//
// b ^ N
//
// where b is the base of the numbering system.
//
// For one-based counting, there is no zero digit. Thus, the set
// of N-digit numbers and the set of (N+1)-digit numbers are
// disjoint sets. Thus, while the number of combinations of
// *exactly* N digits is still b ^ N, the maximum value that
// can be represented by N *or fewer* digits is:
//
// Max(N)
// where N = 1 : b
// where N > 1 : (b ^ N) + Max(N - 1)
//
if (oneBased)
{
// Subtract 1 from 1-based numbers so we can use zero-based
// indexing. The formula for Max(N) given above should now be
// thought of as a limit rather than a maximum.
--number;
}
Debug.Assert(number >= 0);
char[] result;
int b = numericSymbols.Length;
if (number < b)
{
// 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.
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 result;
}
///
/// Convert 1-based number to a Roman numeric string
/// followed by NumberSuffix character.
///
///
/// Roman number is 1-based. The Roman numeric string is a series of symbols. Following
/// is the list of symbols and its value.
///
/// Symbol Value
/// I 1
/// V 5
/// X 10
/// L 50
/// C 100
/// D 500
/// M 1000
///
/// The rule of Roman number prohibits the use of more than 3 consecutive identical symbol
/// but using subtraction of symbol standing for multiples of 10, so the value 4 is written
/// as IV (5-1) rather than IIII.
///
/// Due to the writing rule and the fact that the symbol represents not the numeral digit
/// but the value of the number. Roman number system cannot represent value larger than 3999.
///
/// See, http://www.ccsn.nevada.edu/math/ancient_systems.htm
///
/// However, there exists a more relaxing use of Roman numbers to represent values 4000 and
/// 4999 by using 4 consecutive M. The value 4999 is than written as 'MMMMCMXCIX'. Such use
/// however is not widely accepted.
///
/// See, http://www.guernsey.net/~sgibbs/roman.html
///
/// For values larger than 3999, an overscore is used on the symbol to indicate 1000 multiplication.
/// ___
/// So, value 7000 would be written as VII. This writing rule has a fair amount of disagreement
/// since it is widely understood that it is not invented by the Romans and they rarely had a
/// need for large numbers during their time. Furthermore, accepting this writing rule just
/// for the sake of being able to write larger number would create a new limitation of the values
/// greater than 3,999,999. Unicode 4.0 does not encode these overscore symbols.
///
/// See, http://www.gwydir.demon.co.uk/jo/roman/number.htm
/// http://www.novaroma.org/via_romana/numbers.html
///
/// Implementation-wise, IE adopts a general limitation of 3999 and simply convert the value
/// into a regular numeric form.
///
/// We'll follow the mainstream and adopt the 3999 limit. The fallback would also do would IE does.
///
///
private static string ConvertNumberToRomanString(
int number,
bool uppercase
)
{
if (number > 3999)
{
// Roman numeric string not supported
return number.ToString(CultureInfo.InvariantCulture);
}
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();
}
///
/// Convert number 0 - 9 into Roman numeric
///
/// string builder
/// number to convert
/// Roman numeric char for one five and ten
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]);
}
}
}
internal static bool IsKnownSymbolMarkerStyle(TextMarkerStyle markerStyle)
{
return (
markerStyle == TextMarkerStyle.Disc
|| markerStyle == TextMarkerStyle.Circle
|| markerStyle == TextMarkerStyle.Square
|| markerStyle == TextMarkerStyle.Box
);
}
internal static bool IsKnownIndexMarkerStyle(TextMarkerStyle markerStyle)
{
return (
markerStyle == TextMarkerStyle.Decimal
|| markerStyle == TextMarkerStyle.LowerLatin
|| markerStyle == TextMarkerStyle.UpperLatin
|| markerStyle == TextMarkerStyle.LowerRoman
|| markerStyle == TextMarkerStyle.UpperRoman
);
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- Metadata.cs
- Size.cs
- SerialStream.cs
- AmbientLight.cs
- ArrayHelper.cs
- AccessDataSourceWizardForm.cs
- TableCellCollection.cs
- StringDictionaryWithComparer.cs
- GridViewAutomationPeer.cs
- AlphabetConverter.cs
- WebPageTraceListener.cs
- FixedSOMImage.cs
- X509KeyIdentifierClauseType.cs
- LinqDataSourceDisposeEventArgs.cs
- WebPartHelpVerb.cs
- LinqDataSourceSelectEventArgs.cs
- ProcessHostConfigUtils.cs
- HtmlInputImage.cs
- SynchronizedInputAdaptor.cs
- DesignParameter.cs
- COM2IManagedPerPropertyBrowsingHandler.cs
- CodeLabeledStatement.cs
- RepeaterCommandEventArgs.cs
- StringSorter.cs
- OleDbError.cs
- HTMLTextWriter.cs
- WrappedReader.cs
- OracleParameter.cs
- CheckBoxField.cs
- WebPartVerbsEventArgs.cs
- SamlAuthorizationDecisionStatement.cs
- DataSourceSelectArguments.cs
- SelectorAutomationPeer.cs
- SimpleTextLine.cs
- ImageCodecInfo.cs
- IxmlLineInfo.cs
- PreviewKeyDownEventArgs.cs
- WebServiceData.cs
- CatalogZoneBase.cs
- NavigationWindowAutomationPeer.cs
- Matrix3DValueSerializer.cs
- ModuleElement.cs
- CodeGotoStatement.cs
- RegexEditorDialog.cs
- AppDomainProtocolHandler.cs
- SiteMapHierarchicalDataSourceView.cs
- SafeFileMappingHandle.cs
- BamlRecordReader.cs
- StylusButtonEventArgs.cs
- CodeGotoStatement.cs
- AutomationProperties.cs
- RawUIStateInputReport.cs
- SurrogateEncoder.cs
- GenericRootAutomationPeer.cs
- ResetableIterator.cs
- MethodAccessException.cs
- FileDetails.cs
- DataControlField.cs
- ObservableCollection.cs
- WorkflowPersistenceService.cs
- RtfToXamlReader.cs
- ISO2022Encoding.cs
- FormViewUpdatedEventArgs.cs
- AVElementHelper.cs
- NativeMethods.cs
- HealthMonitoringSection.cs
- UnionCqlBlock.cs
- RightsManagementSuppressedStream.cs
- Translator.cs
- XmlBinaryReader.cs
- ChannelServices.cs
- PngBitmapEncoder.cs
- DayRenderEvent.cs
- TreeBuilderBamlTranslator.cs
- ToolStripActionList.cs
- MailMessage.cs
- Version.cs
- SessionPageStateSection.cs
- ClientRuntimeConfig.cs
- NativeMethods.cs
- RegexMatch.cs
- Material.cs
- MethodBuilderInstantiation.cs
- SecurityPermission.cs
- ElementFactory.cs
- FamilyTypefaceCollection.cs
- OracleLob.cs
- SQLBinaryStorage.cs
- CompilationRelaxations.cs
- Token.cs
- EventLogInternal.cs
- FrugalList.cs
- HttpException.cs
- PolicyStatement.cs
- SafeNativeMethods.cs
- _RequestCacheProtocol.cs
- MergeExecutor.cs
- FileAuthorizationModule.cs
- TreeViewItem.cs
- GlyphsSerializer.cs