internal TexRunShapeData(TextRun run, bool storeGlyph, int startIndex)
: this(run, storeGlyph)
{
SCRIPT_LOGATTR[] scriptLogAttr = run.ScriptLogAttr;
if (startIndex > 0 && scriptLogAttr != null)
{
int num = scriptLogAttr.Length - startIndex;
SCRIPT_LOGATTR[] array = new SCRIPT_LOGATTR[num];
Array.Copy(scriptLogAttr, startIndex, array, 0, num);
m_scriptLogAttr = array;
}
}
internal TexRunShapeData(TextRun run, bool storeGlyph)
{
if (storeGlyph && run.GlyphData != null)
{
m_glyphData = run.GlyphData.GlyphScriptShapeData;
}
m_analysis = run.SCRIPT_ANALYSIS;
m_scriptLogAttr = run.ScriptLogAttr;
m_cachedFont = run.CachedFont;
m_runState = run.State;
m_itemizedScriptId = run.ItemizedScriptId;
}
private static int FindWidthToBreakPosition(TextRun run, Win32DCSafeHandle hdc, FontCache fontCache, float maxWidth, out int width)
{
string text = run.Text;
int[] logicalWidths = run.GetLogicalWidths(hdc, fontCache);
int i = 0;
for (width = 0; i < text.Length && ((float)(width + logicalWidths[i]) <= maxWidth || (!run.ScriptLogAttr[i].IsWhiteSpace && !run.ScriptLogAttr[i].IsSoftBreak)); i++)
{
width += logicalWidths[i];
}
return(i);
}
private static int FindFoldTextPosition_CharacterTrim(TextRun run, Win32DCSafeHandle hdc, FontCache fontCache, float maxWidth)
{
string text = run.Text;
int[] logicalWidths = run.GetLogicalWidths(hdc, fontCache);
int i = 0;
for (int num = 0; i < text.Length && (float)(num + logicalWidths[i]) <= maxWidth; i++)
{
num += logicalWidths[i];
}
return(i);
}
internal Microsoft.ReportingServices.Rendering.RichText.Paragraph GetRichTextParagraph()
{
Microsoft.ReportingServices.Rendering.RichText.Paragraph paragraph = new Microsoft.ReportingServices.Rendering.RichText.Paragraph(this, m_textRuns.Count);
foreach (TextRun textRun in m_textRuns)
{
Microsoft.ReportingServices.Rendering.RichText.TextRun richTextRun = textRun.GetRichTextRun();
if (richTextRun != null)
{
paragraph.Runs.Add(richTextRun);
}
}
return(paragraph);
}
internal Microsoft.ReportingServices.Rendering.RichText.Paragraph GetRichTextParagraph()
{
Microsoft.ReportingServices.Rendering.RichText.Paragraph paragraph = new Microsoft.ReportingServices.Rendering.RichText.Paragraph(this, m_textRuns.Count);
for (int i = 0; i < m_textRuns.Count; i++)
{
Microsoft.ReportingServices.Rendering.RichText.TextRun richTextRun = m_textRuns[i].GetRichTextRun();
if (richTextRun != null)
{
paragraph.Runs.Add(richTextRun);
}
}
return(paragraph);
}
private List <TextRun> ExtractRuns(int startingParaCharIndex, int endingParaCharIndex, SCRIPT_ANALYSIS analysis)
{
List <TextRun> list = new List <TextRun>();
StringBuilder stringBuilder = new StringBuilder();
int num = 0;
int num2 = 0;
TextRun textRun = null;
for (int i = 0; i < m_runs.Count; i++)
{
TextRun textRun2 = m_runs[i];
num2 = num + textRun2.CharacterCount - 1;
int num3 = -1;
if (startingParaCharIndex <= num)
{
num3 = 0;
}
else if (startingParaCharIndex <= num2)
{
num3 = startingParaCharIndex - num;
}
if (num3 >= 0)
{
if (endingParaCharIndex <= num2)
{
int num4 = endingParaCharIndex - num - num3 + 1;
textRun = textRun2.GetSubRun(num3, num4);
textRun.SCRIPT_ANALYSIS = analysis;
stringBuilder.Append(textRun.Text);
list.Add(textRun);
if (endingParaCharIndex == num2 && num4 == 1 && i == m_runs.Count - 1 && textRun.Text[0] == '\n')
{
textRun = textRun2.GetSubRun(num3 + 1, 0);
textRun.SCRIPT_ANALYSIS = analysis;
list.Add(textRun);
}
AnalyzeForBreakPositions(list, stringBuilder.ToString());
return(list);
}
textRun = textRun2.GetSubRun(num3);
textRun.SCRIPT_ANALYSIS = analysis;
stringBuilder.Append(textRun.Text);
list.Add(textRun);
}
num = num2 + 1;
}
AnalyzeForBreakPositions(list, stringBuilder.ToString());
return(list);
}
internal string GetNextTextBlock()
{
if (m_lastRunIndex >= m_runs.Count)
{
m_lastCharIndexInRun = 0;
m_lastRunIndex = 0;
return(null);
}
StringBuilder stringBuilder = new StringBuilder();
bool flag = true;
bool flag2 = false;
while (m_lastRunIndex < m_runs.Count)
{
TextRun textRun = m_runs[m_lastRunIndex];
if (!flag && (textRun.IsPlaceholderTextRun || flag2))
{
break;
}
int length = textRun.Text.Length;
if (stringBuilder.Length + length - m_lastCharIndexInRun > 21845)
{
int num = 21845 - stringBuilder.Length + m_lastCharIndexInRun - 1;
int num2 = Math.Max(num - 100, m_lastCharIndexInRun);
for (int num3 = num; num3 >= num2; num3--)
{
char c = textRun.Text[num3];
if (!char.IsHighSurrogate(c) && !char.IsLetterOrDigit(c))
{
num = ((c != '\r' || num3 - 1 <= m_lastCharIndexInRun) ? num3 : (num3 - 1));
break;
}
}
stringBuilder.Append(textRun.Text, m_lastCharIndexInRun, num - m_lastCharIndexInRun + 1);
m_lastCharIndexInRun = num + 1;
flag2 = textRun.IsPlaceholderTextRun;
return(stringBuilder.ToString());
}
stringBuilder.Append(textRun.Text, m_lastCharIndexInRun, length - m_lastCharIndexInRun);
m_lastCharIndexInRun = 0;
flag = false;
flag2 = textRun.IsPlaceholderTextRun;
m_lastRunIndex++;
}
return(stringBuilder.ToString());
}
internal TextRun GetSubRunForLine(TextBoxContext context, ref bool newLine)
{
AdvanceToNextRun(context);
if (context.TextRunIndex < m_runs.Count)
{
TextRun textRun = m_runs[context.TextRunIndex];
string text = null;
bool flag = false;
if (context.TextRunCharacterIndex == 0)
{
text = (textRun.Text ?? "");
}
else
{
flag = true;
text = textRun.Text.Substring(context.TextRunCharacterIndex);
}
int num = text.IndexOf('\n');
if (num != -1)
{
if (num + 1 < text.Length)
{
text = text.Substring(0, num + 1);
flag = true;
}
newLine = true;
}
if (flag)
{
SCRIPT_LOGATTR[] array = new SCRIPT_LOGATTR[text.Length];
Array.Copy(textRun.ScriptLogAttr, context.TextRunCharacterIndex, array, 0, array.Length);
TextRun textRun2 = textRun.Split(text, array);
textRun2.CharacterIndexInOriginal += context.TextRunCharacterIndex;
textRun2.Clone = true;
context.TextRunCharacterIndex += text.Length;
return(textRun2);
}
context.TextRunCharacterIndex += text.Length;
return(textRun);
}
return(null);
}
internal int GetHeight(Win32DCSafeHandle hdc, FontCache fontCache)
{
if (!m_calculatedHeight)
{
m_calculatedHeight = true;
for (int i = 0; i < m_logicalRuns.Count; i++)
{
TextRun textRun = m_logicalRuns[i];
int ascent = textRun.GetAscent(hdc, fontCache);
if (ascent > m_ascent)
{
m_ascent = ascent;
}
int descent = textRun.GetDescent(hdc, fontCache);
if (descent > m_descent)
{
m_descent = descent;
}
}
if (m_prefix != null)
{
for (int j = 0; j < m_prefix.Count; j++)
{
TextRun textRun2 = m_prefix[j];
int ascent2 = textRun2.GetAscent(hdc, fontCache);
if (ascent2 > m_ascent)
{
m_ascent = ascent2;
}
int descent2 = textRun2.GetDescent(hdc, fontCache);
if (descent2 > m_descent)
{
m_descent = descent2;
}
}
}
}
return(m_ascent + m_descent);
}
private static void AnalyzeForBreakPositions(List <TextRun> itemRuns, string itemsText)
{
if (itemsText.Length != 0)
{
SCRIPT_ANALYSIS psa = itemRuns[0].SCRIPT_ANALYSIS;
SCRIPT_LOGATTR[] array = new SCRIPT_LOGATTR[itemsText.Length];
int num = Win32.ScriptBreak(itemsText, itemsText.Length, ref psa, array);
if (Win32.Failed(num))
{
Marshal.ThrowExceptionForHR(num);
}
int num2 = 0;
for (int i = 0; i < itemRuns.Count; i++)
{
TextRun textRun = itemRuns[i];
int length = textRun.Text.Length;
SCRIPT_LOGATTR[] array2 = new SCRIPT_LOGATTR[length];
Array.Copy(array, num2, array2, 0, length);
textRun.ScriptLogAttr = array2;
num2 += length;
}
}
}
private TextRun GetLastNonLineBreakRun(List <TextRun> runs, out int charIndex, out bool hasNonCRLFChars)
{
for (int num = runs.Count - 1; num >= 0; num--)
{
TextRun textRun = runs[num];
if (textRun.CharacterCount > 0)
{
string text = textRun.Text;
for (charIndex = textRun.CharacterCount - 1; charIndex >= 0; charIndex--)
{
char c = text[charIndex];
if (c != '\n' && c != '\r')
{
hasNonCRLFChars = true;
return(textRun);
}
}
}
}
charIndex = 0;
hasNonCRLFChars = false;
return(runs[runs.Count - 1]);
}
internal Underline(TextRun run, Win32DCSafeHandle hdc, FontCache fontCache, Rectangle layoutRectangle, int x, int baselineY, RPLFormat.WritingModes writingMode)
{
int width = run.GetWidth(hdc, fontCache);
int num = (int)((double)(int)((double)run.UnderlineHeight * 0.085) * 1.5);
switch (writingMode)
{
case RPLFormat.WritingModes.Horizontal:
m_startPoint = new Point(layoutRectangle.X + x, layoutRectangle.Y + baselineY + num);
m_endPoint = new Point(Math.Min(m_startPoint.X + width, layoutRectangle.Right), m_startPoint.Y);
break;
case RPLFormat.WritingModes.Vertical:
m_startPoint = new Point(layoutRectangle.Right - baselineY - num - 1, layoutRectangle.Y + x);
m_endPoint = new Point(m_startPoint.X, Math.Min(m_startPoint.Y + width, layoutRectangle.Bottom));
break;
case RPLFormat.WritingModes.Rotate270:
m_startPoint = new Point(layoutRectangle.X + baselineY + num, layoutRectangle.Bottom - x);
m_endPoint = new Point(m_startPoint.X, Math.Max(m_startPoint.Y - width, layoutRectangle.Top));
break;
}
}
internal static void DrawTextRun(TextRun run, Win32DCSafeHandle hdc, FontCache fontCache, int x, int baselineY, Underline underline)
{
uint crColor = 0u;
try
{
uint colorInt = run.ColorInt;
underline?.Draw(hdc, (int)((double)run.UnderlineHeight * 0.085), colorInt);
crColor = Win32.SetTextColor(hdc, colorInt);
GlyphData glyphData = run.GetGlyphData(hdc, fontCache);
GlyphShapeData glyphScriptShapeData = glyphData.GlyphScriptShapeData;
CachedFont cachedFont = run.GetCachedFont(hdc, fontCache);
fontCache.SelectFontObject(hdc, cachedFont.Hfont);
int num = Win32.ScriptTextOut(hdc, ref cachedFont.ScriptCache, x, baselineY, 4u, IntPtr.Zero, ref run.SCRIPT_ANALYSIS, IntPtr.Zero, 0, glyphScriptShapeData.Glyphs, glyphScriptShapeData.GlyphCount, glyphData.Advances, null, glyphData.GOffsets);
if (Win32.Failed(num))
{
Marshal.ThrowExceptionForHR(num);
}
}
finally
{
crColor = Win32.SetTextColor(hdc, crColor);
}
}
private CaretInfo MapLocation(Win32DCSafeHandle hdc, TextBoxContext location, bool relativeToRun, bool moveCaretToNextLine, out TextRun run)
{
CaretInfo caretInfo = null;
run = null;
int lineYOffset;
int lineHeight;
int textRunCharacterIndex;
bool isFirstLine;
bool isLastLine;
Point paragraphAndRunCoordinates = GetParagraphAndRunCoordinates(hdc, location, moveCaretToNextLine, out lineYOffset, out lineHeight, out run, out textRunCharacterIndex, out isFirstLine, out isLastLine);
if (run != null)
{
GlyphData glyphData = run.GlyphData;
GlyphShapeData glyphScriptShapeData = glyphData.GlyphScriptShapeData;
int piX = 0;
if (glyphData != null && run.CharacterCount > 0)
{
int num = Win32.ScriptCPtoX(textRunCharacterIndex, fTrailing: false, run.CharacterCount, glyphScriptShapeData.GlyphCount, glyphScriptShapeData.Clusters, glyphScriptShapeData.VisAttrs, glyphData.Advances, ref run.SCRIPT_ANALYSIS, ref piX);
if (Win32.Failed(num))
{
Marshal.ThrowExceptionForHR(num);
}
}
caretInfo = new CaretInfo();
CachedFont cachedFont = run.GetCachedFont(hdc, FontCache);
caretInfo.Height = cachedFont.GetHeight(hdc, FontCache);
caretInfo.Ascent = cachedFont.GetAscent(hdc, FontCache);
caretInfo.Descent = cachedFont.GetDescent(hdc, FontCache);
caretInfo.LineHeight = lineHeight;
caretInfo.LineYOffset = lineYOffset;
caretInfo.IsFirstLine = isFirstLine;
caretInfo.IsLastLine = isLastLine;
_ = RTParagraphs;
int y = paragraphAndRunCoordinates.Y - caretInfo.Ascent;
if (relativeToRun)
{
caretInfo.Position = new Point(piX, y);
}
else
{
caretInfo.Position = new Point(paragraphAndRunCoordinates.X + piX, y);
}
}
return(caretInfo);
}
private void CalculateDimensions(Win32DCSafeHandle hdc, FontCache fontCache, bool useVisualRunsIfAvailable)
{
if (m_calculatedDimensions)
{
return;
}
bool flag = useVisualRunsIfAvailable && m_visualRuns != null;
List <TextRun> list = flag ? m_visualRuns : m_logicalRuns;
m_width = 0;
m_prefixWidth = 0;
int count = list.Count;
int num = 0;
for (int i = 0; i < count; i++)
{
TextRun textRun = list[i];
int width = textRun.GetWidth(hdc, fontCache);
m_width += width;
if (!flag)
{
num = Math.Max(textRun.GetWidth(hdc, fontCache, isAtLineEnd: true) - width, num);
}
else if (i == count - 1)
{
num = textRun.GetWidth(hdc, fontCache, isAtLineEnd: true) - width;
}
if (!m_calculatedHeight)
{
int ascent = textRun.GetAscent(hdc, fontCache);
if (ascent > m_ascent)
{
m_ascent = ascent;
}
int descent = textRun.GetDescent(hdc, fontCache);
if (descent > m_descent)
{
m_descent = descent;
}
}
}
m_width += num;
if (m_prefix != null)
{
for (int j = 0; j < m_prefix.Count; j++)
{
TextRun textRun2 = m_prefix[j];
if (!m_calculatedHeight)
{
int ascent2 = textRun2.GetAscent(hdc, fontCache);
if (ascent2 > m_ascent)
{
m_ascent = ascent2;
}
int descent2 = textRun2.GetDescent(hdc, fontCache);
if (descent2 > m_descent)
{
m_descent = descent2;
}
}
m_prefixWidth += textRun2.GetWidth(hdc, fontCache);
}
}
m_calculatedDimensions = true;
m_calculatedHeight = true;
}
private static void RenderHighlightedTextRun(TextBox textBox, Paragraph paragraph, TextRun run, TextRun prevRun, Win32DCSafeHandle hdc, Graphics g, FontCache fontCache, float dpiX, int x, int offsetY, int baselineY, int lineHeight, Rectangle layoutRectangle, int runWidth, int prevRunWidth, int prevRunX, bool lastRunInLine, bool lastLineInParagraph)
{
uint? num = null;
Rectangle?rectangle = null;
bool flag = false;
Color color = run.HighlightColor;
if (!color.IsEmpty)
{
int num2 = (run.HighlightStart >= 0) ? run.HighlightStart : 0;
int num3 = (run.HighlightEnd >= 0) ? run.HighlightEnd : runWidth;
if (lastRunInLine)
{
bool flag2 = run.ScriptAnalysis.fLayoutRTL == 1;
if (lastLineInParagraph && runWidth != 0)
{
if (num2 != num3 && ((flag2 && run.HighlightStart < 0) || (!flag2 && run.HighlightEnd < 0)))
{
if (flag2)
{
num2 -= 5;
int abcA = run.GetGlyphData(hdc, fontCache).ABC.abcA;
if (abcA < 0)
{
num2 += abcA;
}
}
else
{
num3 += 5;
int abcC = run.GetGlyphData(hdc, fontCache).ABC.abcC;
if (abcC < 0)
{
num3 -= abcC;
}
}
}
}
else if (runWidth == 0)
{
if (flag2)
{
num2 -= 5;
}
else
{
num3 += 5;
}
}
}
if (num2 != num3)
{
if (num2 == 0 && prevRun != null && (prevRun.GetGlyphData(hdc, fontCache).ABC.abcC <= 0 || run.GetGlyphData(hdc, fontCache).ABC.abcA < 0))
{
flag = true;
}
if (run.AllowColorInversion && NeedsColorInversion(color, textBox.TextBoxProps.BackgroundColor))
{
color = InvertColor(textBox.TextBoxProps.BackgroundColor);
}
using (Brush brush = new SolidBrush(color))
{
rectangle = ((!textBox.HorizontalText) ? new Rectangle?(new Rectangle(layoutRectangle.Right - offsetY, layoutRectangle.Y + x + num2, lineHeight, num3 - num2)) : new Rectangle?(new Rectangle(layoutRectangle.X + x + num2, layoutRectangle.Y + offsetY - lineHeight, num3 - num2, lineHeight)));
g.FillRectangle(brush, rectangle.Value);
}
if (run.AllowColorInversion && NeedsColorInversion(color, run.TextRunProperties.Color))
{
Color color2 = InvertColor(run.TextRunProperties.Color);
num = (uint)((color2.B << 16) | (color2.G << 8) | color2.R);
}
}
run.HighlightColor = Color.Empty;
}
if (runWidth > 0)
{
textBox.TextBoxProps.DrawTextRun(run, paragraph, hdc, dpiX, fontCache, x, offsetY, baselineY, lineHeight, layoutRectangle);
if (num.HasValue)
{
textBox.TextBoxProps.DrawClippedTextRun(run, paragraph, hdc, dpiX, fontCache, x, offsetY, baselineY, lineHeight, layoutRectangle, num.Value, rectangle.Value);
}
}
if (flag)
{
Rectangle empty = Rectangle.Empty;
empty = (textBox.HorizontalText ? new Rectangle(layoutRectangle.X + x, layoutRectangle.Y + offsetY - lineHeight, prevRunWidth, lineHeight) : new Rectangle(layoutRectangle.Right - offsetY, layoutRectangle.Y + x, lineHeight, prevRunWidth));
Color color3 = prevRun.TextRunProperties.Color;
if (!run.AllowColorInversion || !NeedsColorInversion(color, color3))
{
num = prevRun.ColorInt;
}
else
{
color3 = InvertColor(color3);
num = (uint)((color3.B << 16) | (color3.G << 8) | color3.R);
}
textBox.TextBoxProps.DrawClippedTextRun(prevRun, paragraph, hdc, dpiX, fontCache, prevRunX, offsetY, baselineY, lineHeight, layoutRectangle, num.Value, empty);
}
}
private static void RenderParagraph(TextBox textBox, Paragraph paragraph, Win32DCSafeHandle hdc, FontCache fontCache, int offsetX, ref int offsetY, Rectangle layoutRectangle, float dpiX)
{
List <TextLine> textLines = paragraph.TextLines;
IParagraphProps paragraphProps = paragraph.ParagraphProps;
bool flag = textBox.TextBoxProps.Direction == RPLFormat.Directions.LTR;
RPLFormat.TextAlignments textAlignments = paragraphProps.Alignment;
if (textAlignments == RPLFormat.TextAlignments.General)
{
textAlignments = textBox.TextBoxProps.DefaultAlignment;
if (!flag)
{
switch (textAlignments)
{
case RPLFormat.TextAlignments.Right:
textAlignments = RPLFormat.TextAlignments.Left;
break;
case RPLFormat.TextAlignments.Left:
textAlignments = RPLFormat.TextAlignments.Right;
break;
}
}
}
int num = ConvertToPixels(paragraphProps.LeftIndent, dpiX);
int num2 = ConvertToPixels(paragraphProps.RightIndent, dpiX);
int num3 = ConvertToPixels(paragraphProps.HangingIndent, dpiX);
if (num3 < 0)
{
if (flag)
{
num -= num3;
}
else
{
num2 -= num3;
}
}
if (paragraphProps.ListLevel > 0)
{
int num4 = paragraphProps.ListLevel * ConvertToPixels(10.583333f, dpiX);
if (flag)
{
num += num4;
}
else
{
num2 += num4;
}
}
if (textLines == null || textLines.Count == 0)
{
offsetY += ConvertToPixels(paragraphProps.SpaceBefore, dpiX);
offsetY += ConvertToPixels(paragraphProps.SpaceAfter, dpiX);
return;
}
Graphics graphics = null;
try
{
for (int i = 0; i < textLines.Count; i++)
{
TextLine textLine = textLines[i];
int ascent = textLine.GetAscent(hdc, fontCache);
textLine.GetDescent(hdc, fontCache);
int height = textLine.GetHeight(hdc, fontCache);
if (textLine.FirstLine)
{
offsetY += ConvertToPixels(paragraphProps.SpaceBefore, dpiX);
}
int baselineY = offsetY + ascent;
offsetY += height;
int num5 = offsetX;
switch (textAlignments)
{
case RPLFormat.TextAlignments.Left:
num5 = num;
break;
case RPLFormat.TextAlignments.Center:
{
int num6 = 0;
num6 = ((!textBox.HorizontalText) ? layoutRectangle.Height : layoutRectangle.Width);
num5 = num + (num6 - num - num2) / 2 - textLine.GetWidth(hdc, fontCache) / 2;
break;
}
default:
num5 = ((!textBox.HorizontalText) ? (layoutRectangle.Height - num2 - textLine.GetWidth(hdc, fontCache)) : (layoutRectangle.Width - num2 - textLine.GetWidth(hdc, fontCache)));
break;
}
if (textLine.Prefix != null && textLine.Prefix.Count > 0)
{
int num7 = (!flag) ? (num5 + textLine.GetWidth(hdc, fontCache) + ConvertToPixels(4.233333f, dpiX)) : (num5 - ConvertToPixels(4.233333f, dpiX) - textLine.GetPrefixWidth(hdc, fontCache));
if (num3 < 0)
{
if (flag && textAlignments == RPLFormat.TextAlignments.Left)
{
num7 += num3;
}
else if (!flag && textAlignments == RPLFormat.TextAlignments.Right)
{
num7 -= num3;
}
}
for (int j = 0; j < textLine.Prefix.Count; j++)
{
TextRun textRun = textLine.Prefix[j];
textBox.TextBoxProps.DrawTextRun(textRun, paragraph, hdc, dpiX, fontCache, num7, offsetY, baselineY, height, layoutRectangle);
num7 += textRun.GetWidth(hdc, fontCache);
}
}
if (textLine.FirstLine && num3 != 0)
{
if (flag)
{
switch (textAlignments)
{
case RPLFormat.TextAlignments.Left:
num5 += num3;
break;
case RPLFormat.TextAlignments.Center:
num5 += num3 / 2;
break;
}
}
else
{
switch (textAlignments)
{
case RPLFormat.TextAlignments.Right:
num5 -= num3;
break;
case RPLFormat.TextAlignments.Center:
num5 -= num3 / 2;
break;
}
}
}
int prevRunWidth = 0;
int prevRunX = 0;
TextRun prevRun = null;
int count = textLine.VisualRuns.Count;
for (int k = 0; k < count; k++)
{
TextRun textRun2 = textLine.VisualRuns[k];
int width = textRun2.GetWidth(hdc, fontCache, k == count - 1);
if (!textRun2.IsHighlightTextRun)
{
if (width > 0)
{
textBox.TextBoxProps.DrawTextRun(textRun2, paragraph, hdc, dpiX, fontCache, num5, offsetY, baselineY, height, layoutRectangle);
}
}
else
{
bool flag2 = (flag && k + 1 == count) || (!flag && k == 0);
if (width > 0 || flag2)
{
if (graphics == null)
{
graphics = Graphics.FromHdc(hdc.Handle);
}
RenderHighlightedTextRun(textBox, paragraph, textRun2, prevRun, hdc, graphics, fontCache, dpiX, num5, offsetY, baselineY, height, layoutRectangle, width, prevRunWidth, prevRunX, flag2, textLine.LastLine);
}
}
prevRunX = num5;
prevRunWidth = width;
num5 += width;
prevRun = textRun2;
}
if (textLine.LastLine)
{
offsetY += ConvertToPixels(paragraphProps.SpaceAfter, dpiX);
}
}
}
finally
{
if (graphics != null)
{
graphics.Dispose();
graphics = null;
}
}
}
internal TextRun(string text, TextRun textRun)
: this(text, textRun.TextRunProperties)
{
}
internal HighlightTextRun(string text, TextRun textRun)
: base(text, textRun.TextRunProperties)
{
m_charIndexInOriginal = textRun.CharacterIndexInOriginal;
}
internal void ScriptLayout(Win32DCSafeHandle hdc, FontCache fontCache)
{
if (m_visualRuns != null)
{
return;
}
int count = m_logicalRuns.Count;
if (count == 0)
{
return;
}
byte[] array = new byte[count];
int[] array2 = new int[count];
for (int i = 0; i < count; i++)
{
array[i] = (byte)m_logicalRuns[i].ScriptAnalysis.s.uBidiLevel;
}
int num = Win32.ScriptLayout(count, array, null, array2);
if (Win32.Failed(num))
{
Marshal.ThrowExceptionForHR(num);
}
m_visualRuns = new List <TextRun>(count);
for (int j = 0; j < count; j++)
{
m_visualRuns.Add(null);
}
for (int k = 0; k < count; k++)
{
m_visualRuns[array2[k]] = m_logicalRuns[k];
}
int num2 = 0;
int l = -1;
for (int m = 0; m < count; m++)
{
TextRun textRun = m_visualRuns[m];
textRun.UnderlineHeight = 0;
if (textRun.TextRunProperties.TextDecoration == RPLFormat.TextDecorations.Underline)
{
if (l < 0)
{
l = m;
}
int height = textRun.GetHeight(hdc, fontCache);
if (height > num2)
{
num2 = height;
}
}
else if (l >= 0)
{
for (; l < m; l++)
{
m_visualRuns[l].UnderlineHeight = num2;
}
num2 = 0;
l = -1;
}
}
if (l >= 0)
{
for (; l < count; l++)
{
m_visualRuns[l].UnderlineHeight = num2;
}
}
}
private CaretInfo MapLocation(Graphics g, TextBoxContext location, bool relativeToRun, bool moveCaretToNextLine, out TextRun run)
{
Win32DCSafeHandle win32DCSafeHandle = null;
bool flag = false;
try
{
if (g == null)
{
flag = true;
g = Graphics.FromHwnd(IntPtr.Zero);
}
win32DCSafeHandle = new Win32DCSafeHandle(g.GetHdc(), ownsHandle: false);
return(MapLocation(win32DCSafeHandle, location, relativeToRun, moveCaretToNextLine, out run));
}
finally
{
if (!win32DCSafeHandle.IsInvalid)
{
g.ReleaseHdc();
}
if (flag)
{
g.Dispose();
g = null;
}
}
}
private void SetHighlighting(List <Paragraph> paragraphs, Win32DCSafeHandle hdc, RTSelectionHighlight highlight, TextRun runStart, TextRun runEnd, int x1, int x2)
{
if (runStart == runEnd)
{
if (x1 != x2)
{
if (x1 < x2)
{
runStart.HighlightStart = x1;
runStart.HighlightEnd = x2;
}
else
{
runStart.HighlightStart = x2;
runStart.HighlightEnd = x1;
}
runStart.HighlightColor = highlight.Color;
runStart.AllowColorInversion = highlight.AllowColorInversion;
}
return;
}
bool flag = false;
bool flag2 = false;
Color color = highlight.Color;
bool allowColorInversion = highlight.AllowColorInversion;
for (int i = highlight.SelectionStart.ParagraphIndex; i <= highlight.SelectionEnd.ParagraphIndex; i++)
{
int count = paragraphs[i].TextLines.Count;
for (int j = 0; j < count; j++)
{
List <TextRun> logicalRuns = paragraphs[i].TextLines[j].LogicalRuns;
int count2 = logicalRuns.Count;
for (int k = 0; k < count2; k++)
{
TextRun textRun = logicalRuns[k];
bool flag3 = textRun.ScriptAnalysis.fLayoutRTL == 0;
if (textRun == runStart)
{
flag2 = true;
if (flag3 && x1 < textRun.GetWidth(hdc, FontCache))
{
textRun.HighlightStart = x1;
textRun.HighlightEnd = -1;
textRun.HighlightColor = color;
textRun.AllowColorInversion = allowColorInversion;
}
else if (!flag3 && x1 > 0)
{
textRun.HighlightStart = -1;
textRun.HighlightEnd = x1;
textRun.HighlightColor = color;
textRun.AllowColorInversion = allowColorInversion;
}
continue;
}
if (textRun == runEnd)
{
flag2 = false;
if (flag3 && x2 > 0)
{
textRun.HighlightStart = -1;
textRun.HighlightEnd = x2;
textRun.HighlightColor = color;
textRun.AllowColorInversion = allowColorInversion;
}
else if (!flag3 && x2 < textRun.GetWidth(hdc, FontCache))
{
textRun.HighlightStart = x2;
textRun.HighlightEnd = -1;
textRun.HighlightColor = color;
textRun.AllowColorInversion = allowColorInversion;
}
flag = true;
break;
}
if (flag2)
{
textRun.HighlightStart = -1;
textRun.HighlightEnd = -1;
textRun.HighlightColor = color;
textRun.AllowColorInversion = allowColorInversion;
}
}
if (flag)
{
break;
}
}
if (flag)
{
break;
}
}
}
internal PlaceholderTextRun(string text, TextRun textRun)
: base(text, textRun.TextRunProperties)
{
}
private TextBoxContext GetParagraphAndRunIndex(Graphics g, Paragraph paragraph, int leftIndent, int rightIndent, int hangingIndent, int x, int y, bool isLTR, bool lastParagraph, out TextRun run, out int runX, out bool atEndOfLine)
{
Win32DCSafeHandle win32DCSafeHandle = null;
bool flag = false;
try
{
if (g == null)
{
flag = true;
g = Graphics.FromHwnd(IntPtr.Zero);
}
win32DCSafeHandle = new Win32DCSafeHandle(g.GetHdc(), ownsHandle: false);
runX = x;
run = null;
atEndOfLine = false;
for (int i = 0; i < paragraph.TextLines.Count; i++)
{
TextLine textLine = paragraph.TextLines[i];
y -= textLine.GetHeight(win32DCSafeHandle, FontCache);
if (textLine.FirstLine)
{
y -= TextBox.ConvertToPixels(paragraph.ParagraphProps.SpaceBefore, Dpi);
}
else if (textLine.LastLine)
{
y -= TextBox.ConvertToPixels(paragraph.ParagraphProps.SpaceAfter, Dpi);
}
if (y >= 0 && i + 1 != paragraph.TextLines.Count)
{
continue;
}
int width = textLine.GetWidth(win32DCSafeHandle, FontCache);
if (x > WidthInPX)
{
atEndOfLine = (width > 0);
run = GetLastNonLineBreakRun(textLine.LogicalRuns, out int charIndex, out bool hasNonCRLFChars);
TextBoxContext textBoxContext = new TextBoxContext();
textBoxContext.TextRunIndex = run.TextRunProperties.IndexInParagraph;
if (hasNonCRLFChars && run.CharacterCount > 0)
{
textBoxContext.TextRunCharacterIndex = run.CharacterIndexInOriginal + charIndex + 1;
}
else
{
textBoxContext.TextRunCharacterIndex = run.CharacterIndexInOriginal;
}
run = null;
return(textBoxContext);
}
if (x < 0)
{
atEndOfLine = false;
run = GetFirstNonLineBreakRun(textLine.LogicalRuns, out int charIndex2);
TextBoxContext result = new TextBoxContext
{
TextRunIndex = run.TextRunProperties.IndexInParagraph,
TextRunCharacterIndex = run.CharacterIndexInOriginal + charIndex2
};
run = null;
return(result);
}
RPLFormat.TextAlignments textAlignments = paragraph.ParagraphProps.Alignment;
if (textAlignments == RPLFormat.TextAlignments.General)
{
textAlignments = m_rttextbox.TextBoxProps.DefaultAlignment;
if (!isLTR)
{
switch (textAlignments)
{
case RPLFormat.TextAlignments.Left:
textAlignments = RPLFormat.TextAlignments.Right;
break;
case RPLFormat.TextAlignments.Right:
textAlignments = RPLFormat.TextAlignments.Left;
break;
}
}
}
switch (textAlignments)
{
case RPLFormat.TextAlignments.Center:
runX = x - (leftIndent + (WidthInPX - leftIndent - rightIndent) / 2 - width / 2);
break;
case RPLFormat.TextAlignments.Right:
runX = x - (WidthInPX - width - rightIndent);
break;
default:
runX = x - leftIndent;
break;
}
if (textLine.FirstLine && hangingIndent != 0)
{
if (isLTR)
{
switch (textAlignments)
{
case RPLFormat.TextAlignments.Left:
runX -= hangingIndent;
break;
case RPLFormat.TextAlignments.Center:
runX -= hangingIndent / 2;
break;
}
}
else
{
switch (textAlignments)
{
case RPLFormat.TextAlignments.Right:
runX += hangingIndent;
break;
case RPLFormat.TextAlignments.Center:
runX += hangingIndent / 2;
break;
}
}
}
runX = Math.Max(0, runX);
return(GetParagraphAndRunIndex(win32DCSafeHandle, paragraph, textLine, x, width, lastParagraph, out run, ref runX, out atEndOfLine));
}
return(null);
}
finally
{
if (!win32DCSafeHandle.IsInvalid)
{
g.ReleaseHdc();
}
if (flag)
{
g.Dispose();
g = null;
}
}
}
private TextBoxContext GetParagraphAndRunIndex(Graphics g, int x, int y, out TextRun run, out int runX, out bool atEndOfLine)
{
List <Paragraph> rTParagraphs = RTParagraphs;
Paragraph paragraph = null;
int num = 0;
int num2 = 0;
int num3 = 0;
int i = 0;
bool flag = true;
run = null;
runX = 0;
atEndOfLine = false;
if (rTParagraphs == null || rTParagraphs.Count == 0)
{
return(null);
}
if (y < 0)
{
y = 0;
}
for (; i < rTParagraphs.Count; i++)
{
paragraph = rTParagraphs[i];
if ((y < paragraph.OffsetY || y >= paragraph.OffsetY + paragraph.Height) && i + 1 != rTParagraphs.Count)
{
continue;
}
y -= paragraph.OffsetY;
num = TextBox.ConvertToPixels(paragraph.ParagraphProps.LeftIndent, Dpi);
num2 = TextBox.ConvertToPixels(paragraph.ParagraphProps.RightIndent, Dpi);
num3 = TextBox.ConvertToPixels(paragraph.ParagraphProps.HangingIndent, Dpi);
flag = (m_rttextbox.TextBoxProps.Direction == RPLFormat.Directions.LTR);
if (num3 < 0)
{
if (flag)
{
num -= num3;
}
else
{
num2 -= num3;
}
}
int listLevel = paragraph.ParagraphProps.ListLevel;
if (listLevel > 0)
{
int num4 = listLevel * TextBox.ConvertToPixels(10.583333f, Dpi);
if (flag)
{
num += num4;
}
else
{
num2 += num4;
}
}
break;
}
TextBoxContext paragraphAndRunIndex = GetParagraphAndRunIndex(g, paragraph, num, num2, num3, x, y, flag, i == rTParagraphs.Count - 1, out run, out runX, out atEndOfLine);
if (paragraphAndRunIndex != null)
{
paragraphAndRunIndex.ParagraphIndex = i;
}
return(paragraphAndRunIndex);
}
private Point GetParagraphAndRunCoordinates(Win32DCSafeHandle hdc, TextBoxContext location, bool moveCaretToNextLine, out int lineYOffset, out int lineHeight, out TextRun textRun, out int textRunCharacterIndex, out bool isFirstLine, out bool isLastLine)
{
int num = 0;
int textRunIndex = location.TextRunIndex;
textRunCharacterIndex = location.TextRunCharacterIndex;
lineYOffset = 0;
lineHeight = 0;
textRun = null;
isFirstLine = true;
isLastLine = true;
List <Paragraph> rTParagraphs = RTParagraphs;
if (rTParagraphs == null || location.ParagraphIndex >= rTParagraphs.Count)
{
return(Point.Empty);
}
Paragraph paragraph = rTParagraphs[location.ParagraphIndex];
int num2 = paragraph.OffsetY + TextBox.ConvertToPixels(paragraph.ParagraphProps.SpaceBefore, Dpi);
int num3 = TextBox.ConvertToPixels(paragraph.ParagraphProps.LeftIndent, Dpi);
int num4 = TextBox.ConvertToPixels(paragraph.ParagraphProps.RightIndent, Dpi);
int num5 = TextBox.ConvertToPixels(paragraph.ParagraphProps.HangingIndent, Dpi);
bool flag = m_rttextbox.TextBoxProps.Direction == RPLFormat.Directions.LTR;
if (num5 < 0)
{
if (flag)
{
num3 -= num5;
}
else
{
num4 -= num5;
}
}
int listLevel = paragraph.ParagraphProps.ListLevel;
if (listLevel > 0)
{
int num6 = listLevel * TextBox.ConvertToPixels(10.583333f, Dpi);
if (flag)
{
num3 += num6;
}
else
{
num4 += num6;
}
}
for (int i = 0; i < paragraph.TextLines.Count; i++)
{
TextLine textLine = paragraph.TextLines[i];
int descent = textLine.GetDescent(hdc, FontCache);
lineHeight = textLine.GetHeight(hdc, FontCache);
lineYOffset = num2;
num2 += lineHeight;
RPLFormat.TextAlignments textAlignments = paragraph.ParagraphProps.Alignment;
if (textAlignments == RPLFormat.TextAlignments.General)
{
textAlignments = m_rttextbox.TextBoxProps.DefaultAlignment;
if (!flag)
{
switch (textAlignments)
{
case RPLFormat.TextAlignments.Left:
textAlignments = RPLFormat.TextAlignments.Right;
break;
case RPLFormat.TextAlignments.Right:
textAlignments = RPLFormat.TextAlignments.Left;
break;
}
}
}
switch (textAlignments)
{
case RPLFormat.TextAlignments.Center:
num = num3 + (WidthInPX - num3 - num4) / 2 - textLine.GetWidth(hdc, FontCache) / 2;
break;
case RPLFormat.TextAlignments.Right:
num = WidthInPX - textLine.GetWidth(hdc, FontCache) - num4;
break;
default:
num = num3;
break;
}
if (textLine.FirstLine && num5 != 0)
{
if (flag)
{
switch (textAlignments)
{
case RPLFormat.TextAlignments.Left:
num += num5;
break;
case RPLFormat.TextAlignments.Center:
num += num5 / 2;
break;
}
}
else
{
switch (textAlignments)
{
case RPLFormat.TextAlignments.Right:
num -= num5;
break;
case RPLFormat.TextAlignments.Center:
num -= num5 / 2;
break;
}
}
}
int count = textLine.VisualRuns.Count;
for (int j = 0; j < count; j++)
{
textRun = textLine.VisualRuns[j];
if (textRun.TextRunProperties.IndexInParagraph == textRunIndex && textRunCharacterIndex >= textRun.CharacterIndexInOriginal)
{
bool flag2 = (moveCaretToNextLine || textRun.CharacterCount <= 0 || textRun.Text[textRun.CharacterCount - 1] != '\n') ? (textRunCharacterIndex <= textRun.CharacterIndexInOriginal + textRun.CharacterCount) : (textRunCharacterIndex < textRun.CharacterIndexInOriginal + textRun.CharacterCount);
if (flag2 || (i + 1 == paragraph.TextLines.Count && j + 1 == count))
{
if (moveCaretToNextLine && textRunCharacterIndex == textRun.CharacterIndexInOriginal + textRun.CharacterCount && j + 1 == count && i + 1 < paragraph.TextLines.Count)
{
location = location.Clone();
if (paragraph.TextLines[i + 1].VisualRuns[0].TextRunProperties.IndexInParagraph != textRunIndex)
{
location.TextRunIndex++;
location.TextRunCharacterIndex = 0;
}
Point paragraphAndRunCoordinates = GetParagraphAndRunCoordinates(hdc, location, moveCaretToNextLine: false, out lineYOffset, out lineHeight, out textRun, out textRunCharacterIndex, out isFirstLine, out isLastLine);
textRunCharacterIndex = Math.Max(textRunCharacterIndex - 1, 0);
return(paragraphAndRunCoordinates);
}
textRunCharacterIndex -= textRun.CharacterIndexInOriginal;
isFirstLine = textLine.FirstLine;
isLastLine = textLine.LastLine;
return(new Point(num, num2 - descent));
}
}
num += textRun.GetWidth(hdc, FontCache);
}
}
textRun = null;
return(Point.Empty);
}
private static void FoldLine(Paragraph paragraph, TextLine line, Win32DCSafeHandle hdc, FontCache fontCache, FlowContext flowContext, bool wordTrim, Stack <int> lineRunsIndex, Stack <int> lineRunsCharIndex, float maxWidth, int lineIndents)
{
int count = line.LogicalRuns.Count;
float num = 0f;
for (int i = 0; i < count; i++)
{
num += (float)line.LogicalRuns[i].GetWidth(hdc, fontCache);
}
int num2 = -1;
bool flag = false;
for (int num3 = count - 1; num3 >= 0; num3--)
{
TextRun textRun = line.LogicalRuns[num3];
num -= (float)textRun.GetWidth(hdc, fontCache);
SCRIPT_LOGATTR?nextCharLogAttr = null;
if (num3 != count - 1)
{
TextRun textRun2 = line.LogicalRuns[num3 + 1];
if (textRun2.CharacterCount > 0)
{
nextCharLogAttr = textRun2.ScriptLogAttr[0];
}
}
if (!textRun.IsPlaceholderTextRun)
{
flag = true;
int num4 = 0;
num4 = ((!wordTrim) ? FindFoldTextPosition_CharacterTrim(textRun, hdc, fontCache, maxWidth - num) : FindFoldTextPosition_TextRunTrim(textRun, hdc, fontCache, maxWidth - num, nextCharLogAttr));
if (num4 > 0)
{
FoldLineAt(line, num3, num4, flowContext.Context, lineRunsIndex, lineRunsCharIndex);
return;
}
}
else if (num2 > 0 && textRun.TextRunProperties.IndexInParagraph != num2)
{
flag = true;
}
num2 = textRun.TextRunProperties.IndexInParagraph;
}
if (line.LogicalRuns.Count > 1)
{
if (!flag)
{
return;
}
int num5;
for (num5 = line.LogicalRuns.Count - 1; num5 > 0; num5--)
{
flowContext.Context.TextRunIndex = lineRunsIndex.Pop();
flowContext.Context.TextRunCharacterIndex = lineRunsCharIndex.Pop();
TextRun textRun3 = line.LogicalRuns[num5];
if (!textRun3.IsPlaceholderTextRun || textRun3.CharacterIndexInOriginal == 0)
{
break;
}
}
line.LogicalRuns.RemoveRange(num5, line.LogicalRuns.Count - num5);
}
else
{
if (!flag)
{
return;
}
int num6 = 1;
if (maxWidth > 0f)
{
flowContext.ForcedCharTrim = true;
if (flowContext.VerticalCanGrow)
{
num6 = FindWidthToBreakPosition(line.LogicalRuns[0], hdc, fontCache, maxWidth, out int width);
flowContext.CharTrimmedRunWidth = Math.Max(flowContext.CharTrimmedRunWidth, width + lineIndents);
}
else
{
num6 = FindFoldTextPosition_CharacterTrim(line.LogicalRuns[0], hdc, fontCache, maxWidth);
}
if (num6 == 0)
{
num6 = 1;
}
}
else if (line.FirstLine && paragraph.ParagraphProps.HangingIndent > 0f)
{
num6 = 0;
if (flowContext.Updatable)
{
paragraph.Updated = true;
}
}
FoldLineAt(line, 0, num6, flowContext.Context, lineRunsIndex, lineRunsCharIndex);
}
}
private TextBoxContext GetParagraphAndRunIndex(Win32DCSafeHandle hdc, Paragraph paragraph, TextLine line, int x, int lineWidth, bool lastParagraph, out TextRun run, ref int runX, out bool atEndOfLine)
{
atEndOfLine = false;
run = null;
int count = line.VisualRuns.Count;
for (int i = 0; i < count; i++)
{
run = line.VisualRuns[i];
int width = run.GetWidth(hdc, FontCache, i == count - 1);
if (runX - width <= 0 || i + 1 == count)
{
if (runX - width > 0)
{
atEndOfLine = true;
if (run.ScriptAnalysis.fLayoutRTL == 1 && x >= lineWidth)
{
run = line.VisualRuns[count - 1];
return(new TextBoxContext
{
TextRunIndex = run.TextRunProperties.IndexInParagraph,
TextRunCharacterIndex = run.CharacterIndexInOriginal
});
}
}
int num = 0;
int characterCount = run.CharacterCount;
if (characterCount > 0)
{
if ((run.ScriptAnalysis.fLayoutRTL == 0 && i + 1 == count) || (run.ScriptAnalysis.fLayoutRTL == 1 && i == 0))
{
if (width <= 0)
{
string text = run.Text;
if (characterCount > 1 && text[characterCount - 2] == '\r' && text[characterCount - 1] == '\n')
{
num = ((run.ScriptAnalysis.fLayoutRTL != 0) ? (-1) : (-2));
}
else if (text[characterCount - 1] == '\n' && run.ScriptAnalysis.fLayoutRTL == 0)
{
if (i > 0)
{
run = line.VisualRuns[i - 1];
if (run.CharacterCount > 0 && run.Text[run.CharacterCount - 1] == '\r')
{
num = -1;
}
}
else
{
num = -1;
}
}
}
else if (i + 1 == count && (run.Text[characterCount - 1] == '\r' || run.Text[characterCount - 1] == '\n'))
{
num = -1;
}
else if (i == 0 && (run.Text[0] == '\r' || run.Text[0] == '\n'))
{
num = -1;
}
}
else if (i == 0 && (run.Text[0] == '\r' || run.Text[0] == '\n'))
{
num = -1;
}
}
else if (lastParagraph && line.LastLine && !line.FirstLine)
{
num = 1;
}
return(new TextBoxContext
{
TextRunIndex = run.TextRunProperties.IndexInParagraph,
TextRunCharacterIndex = run.CharacterIndexInOriginal + num
});
}
runX -= width;
}
return(null);
}
internal override void DrawTextRun(Win32DCSafeHandle hdc, FontCache fontCache, ReportTextBox textBox, Microsoft.ReportingServices.Rendering.RichText.TextRun run, TypeCode typeCode, RPLFormat.TextAlignments textAlign, RPLFormat.VerticalAlignments verticalAlign, RPLFormat.WritingModes writingMode, RPLFormat.Directions direction, Point pointPosition, System.Drawing.Rectangle layoutRectangle, int lineHeight, int baselineY)
{
if (!string.IsNullOrEmpty(run.Text))
{
int x;
int baselineY2;
switch (writingMode)
{
case RPLFormat.WritingModes.Horizontal:
x = layoutRectangle.X + pointPosition.X;
baselineY2 = layoutRectangle.Y + baselineY;
break;
case RPLFormat.WritingModes.Vertical:
x = layoutRectangle.X + (layoutRectangle.Width - baselineY);
baselineY2 = layoutRectangle.Y + pointPosition.X;
break;
case RPLFormat.WritingModes.Rotate270:
x = layoutRectangle.X + baselineY;
baselineY2 = layoutRectangle.Y + layoutRectangle.Height - pointPosition.X;
break;
default:
throw new NotSupportedException();
}
Underline underline = null;
if (run.UnderlineHeight > 0)
{
underline = new Underline(run, hdc, fontCache, layoutRectangle, pointPosition.X, baselineY, writingMode);
}
if (!IsEmf)
{
Microsoft.ReportingServices.Rendering.RichText.TextBox.DrawTextRun(run, hdc, fontCache, x, baselineY2, underline);
}
else
{
Microsoft.ReportingServices.Rendering.RichText.TextBox.ExtDrawTextRun(run, hdc, fontCache, x, baselineY2, underline);
}
}
}