//Automatically called for each chunk of text in the PDF
public override void RenderText(TextRenderInfo renderInfo)
{
base.RenderText(renderInfo);
//See if the current chunk contains the text
var startPosition = System.Globalization.CultureInfo.CurrentCulture.CompareInfo.IndexOf(renderInfo.GetText(), this.TextToSearchFor, this.CompareOptions);
//If not found bail
if (startPosition < 0)
{
return;
}
//Grab the individual characters
var chars = renderInfo.GetCharacterRenderInfos().Skip(startPosition).Take(this.TextToSearchFor.Length).ToList();
//Grab the first and last character
var firstChar = chars.First();
var lastChar = chars.Last();
//Get the bounding box for the chunk of text
var bottomLeft = firstChar.GetDescentLine().GetStartPoint();
var topRight = lastChar.GetAscentLine().GetEndPoint();
//Create a rectangle from it
var rect = new iTextSharp.text.Rectangle(bottomLeft[Vector.I1], bottomLeft[Vector.I2], topRight[Vector.I1], topRight[Vector.I2]);
//Add this to our main collection
this.myPoints.Add(new RectAndText(rect, this.TextToSearchFor));
}
public override void RenderText(TextRenderInfo renderInfo)
{
base.RenderText(renderInfo);
//GraphicsState gs = (GraphicsState)gsField.GetValue(renderInfo);//expensive???
//Font font = new Font { Name = string.Join(", ", gs.Font.FullFontName[0]), Size = gs.FontSize };
List <CharBox> cbs = new List <CharBox>();
IList <TextRenderInfo> cris = renderInfo.GetCharacterRenderInfos();
foreach (TextRenderInfo cri in cris)
{
Vector baseLeft = cri.GetBaseline().GetStartPoint();
Vector topRight = cri.GetAscentLine().GetEndPoint();
float x = baseLeft[Vector.I1];
float y = topRight[Vector.I2];
CharBox cb = new CharBox
{
Char = cri.GetText(),
R = new System.Drawing.RectangleF
{
X = x - pageSize.X,
Y = pageSize.Height + pageSize.Y - y,//(!)basic positioning point is char's baseLine, not ascentLine
Width = topRight[Vector.I1] - x,
Height = y - baseLeft[Vector.I2],
},
//Font = font
};
cbs.Add(cb);
}
CharBoxs.AddRange(cbs);
}
public override void EventOccurred(IEventData data, EventType type)
{
if (!type.Equals(EventType.RENDER_TEXT))
{
return;
}
TextRenderInfo renderInfo = (TextRenderInfo)data;
string curFont = renderInfo.GetFont().GetFontProgram().ToString();
float curFontSize = renderInfo.GetFontSize();
IList <TextRenderInfo> text = renderInfo.GetCharacterRenderInfos();
foreach (TextRenderInfo t in text)
{
string letter = t.GetText();
Vector l_start = t.GetBaseline().GetStartPoint(),
l_end = t.GetAscentLine().GetEndPoint();
Rectangle l_rect = new Rectangle(l_start.Get(0), l_start.Get(1),
l_end.Get(0) - l_start.Get(0), l_end.Get(1) - l_start.Get(1));
if (letter != " " && !letter.Contains(' '))
{
TextResult.Add(new TextChunk()
{
Text = letter,
Rect = l_rect,
FontFamily = curFont,
FontSize = curFontSize,
});
}
}
}
public virtual void RenderText(TextRenderInfo renderInfo)
{
if (renderInfo.PdfString.ToUnicodeString().Length == 0)
{
return;
}
// if true, than clipping path was completely cleaned
if (newClippingPath.IsEmpty())
{
LineSegment baseline = renderInfo.GetUnscaledBaseline();
chunks.Add(new PdfCleanUpContentChunk.Text(renderInfo.PdfString, baseline.GetStartPoint(),
baseline.GetEndPoint(), false, strNumber));
}
else
{
foreach (TextRenderInfo ri in renderInfo.GetCharacterRenderInfos())
{
bool isAllowed = filter.AllowText(ri);
LineSegment baseline = ri.GetUnscaledBaseline();
chunks.Add(new PdfCleanUpContentChunk.Text(ri.PdfString, baseline.GetStartPoint(),
baseline.GetEndPoint(), isAllowed, strNumber));
}
}
++strNumber;
}
virtual public void RenderText(TextRenderInfo renderInfo)
{
foreach (TextRenderInfo glyphInfo in renderInfo.GetCharacterRenderInfos())
{
deleg.RenderText(glyphInfo);
}
}
private string GetTextFromRectangle(Rectangle rectangle)
{
string rectText = String.Empty;
TextRegionEventFilter textRegionEventFilter = new TextRegionEventFilter(rectangle);
LocationTextExtractionStrategy extractionStrategy = new LocationTextExtractionStrategy();
foreach (IEventData textRender in textRenderList)
{
if (textRegionEventFilter.IsInsideRectangle(textRender, EventType.RENDER_TEXT))
{
extractionStrategy.EventOccurred(textRender, EventType.RENDER_TEXT);
}
else if (textRegionEventFilter.Accept(textRender, EventType.RENDER_TEXT))
{
TextRenderInfo textRenderInfo = (TextRenderInfo)textRender;
IList <TextRenderInfo> renderInfoList = textRenderInfo.GetCharacterRenderInfos();
for (int index = 0; index < renderInfoList.Count(); index++)
{
if (textRegionEventFilter.IsInsideRectangle(renderInfoList[index], EventType.RENDER_TEXT))
{
extractionStrategy.EventOccurred(renderInfoList[index], EventType.RENDER_TEXT);
}
}
}
}
rectText = extractionStrategy.GetResultantText();
return(rectText);
}
//--------------------------------------------------------------------------------------------------
public void RenderText(TextRenderInfo renderInfo)
{
LineSegment segment = renderInfo.GetBaseline();
TextChunk location = new TextChunk(renderInfo.GetText(), segment.GetStartPoint(), segment.GetEndPoint(), renderInfo.GetSingleSpaceWidth());
location.iPage = Page;
int renderInfoTextLength = new StringInfo(renderInfo.GetText()).LengthInTextElements;
if (renderInfoTextLength == 1)
{
location.AscentLines.Add(renderInfo.GetAscentLine());
location.DescentLines.Add(renderInfo.GetDescentLine());
}
else
{
IList <TextRenderInfo> infos = renderInfo.GetCharacterRenderInfos();
System.Diagnostics.Debug.Assert(infos != null);
System.Diagnostics.Debug.Assert(renderInfoTextLength == infos.Count);
foreach (TextRenderInfo info in infos)
{
location.AscentLines.Add(info.GetAscentLine());
location.DescentLines.Add(info.GetDescentLine());
}
}
m_LocationalResult.Add(location);
}
public override void RenderText(TextRenderInfo renderInfo)
{
base.RenderText(renderInfo);
List <CharBox> cbs = new List <CharBox>();
IList <TextRenderInfo> cris = renderInfo.GetCharacterRenderInfos();
foreach (TextRenderInfo cri in cris)
{
Vector baseLeft = cri.GetBaseline().GetStartPoint();
Vector topRight = cri.GetAscentLine().GetEndPoint();
float x = baseLeft[Vector.I1];
float y = topRight[Vector.I2];
CharBox cb = new CharBox
{
Char = cri.GetText(),
R = new System.Drawing.RectangleF
{
X = x - pageSize.X,
Y = pageSize.Height + pageSize.Y - y,//(!)basic positioning point is char's baseLine, not ascentLine
Width = topRight[Vector.I1] - x,
Height = y - baseLeft[Vector.I2],
},
//Font = font,
//FontSize = fontSize
};
cbs.Add(cb);
}
CharBoxs.AddRange(cbs);
}
public void RenderText(TextRenderInfo renderInfo)
{
foreach (TextRenderInfo info in renderInfo.GetCharacterRenderInfos())
{
this.textextractionstrategy.RenderText(info);
}
}
public override void RenderText(TextRenderInfo renderInfo)
{
foreach (TextRenderInfo tri in renderInfo.GetCharacterRenderInfos())
{
base.RenderText(tri);
}
}
protected override IList <CharacterRenderInfo> ToCRI(TextRenderInfo tri)
{
IList <CharacterRenderInfo> cris = new List <CharacterRenderInfo>();
foreach (TextRenderInfo subTri in tri.GetCharacterRenderInfos())
{
cris.Add(new CCharacterRenderInfo(subTri));
}
return(cris);
}
public override void EventOccurred(IEventData data, EventType type)
{
base.EventOccurred(data, type);
TextRenderInfo tri = data as TextRenderInfo;
//if (type != EventType.RENDER_TEXT)
if (tri == null)
{
return;
}
PdfFont font = tri.GetFont();//it has been checked that it returns the same font object.
float fontSize = Math.Abs/*sometimes it is negative in iText7*/ (tri.GetFontSize());
//if (font.GetAscent("I", fontSize) == 0)
// fontSize = 0;
List <CharBox> cbs = new List <CharBox>();
IList <TextRenderInfo> cris = tri.GetCharacterRenderInfos();
foreach (TextRenderInfo cri in cris)
{
Vector baseLeft = cri.GetBaseline().GetStartPoint();
Vector topRight = cri.GetAscentLine().GetEndPoint();
//float rise = cri.GetRise();
//if (rise != 0)
// rise = rise;
float fontHeightFromBaseLine = topRight.Get(Vector.I2) - baseLeft.Get(Vector.I2);
//if (fontSize > 0)
//{
// float fontHeightFromBaseLine2 = fontSize * 0.75f/*(?)convertion from PX to PT*/;//!!!this calculation is heuristic and coincides with cri.GetAscentLine().GetEndPoint().Get(Vector.I2) - bottomLeft.Get(Vector.I2) in iText5
// if (fontHeightFromBaseLine > fontHeightFromBaseLine2)
// fontHeightFromBaseLine = fontHeightFromBaseLine2;
//}
float x = baseLeft.Get(Vector.I1);
//float y = topRight.Get(Vector.I2);
CharBox cb = new CharBox
{
Char = cri.GetText(),
R = new System.Drawing.RectangleF
{
X = x - pageSize.X,
Y = pageSize.Height + pageSize.Y - baseLeft.Get(Vector.I2) - fontHeightFromBaseLine,//(!)basic positioning point is char's baseLine, not ascentLine
Width = topRight.Get(Vector.I1) - x,
//Height = y - bottomLeft.Get(Vector.I2)// + d,
Height = fontHeightFromBaseLine
},
Font = font,
FontSize = fontSize
};
cbs.Add(cb);
}
CharBoxs.AddRange(cbs);
}
public override void EventOccurred(IEventData data, EventType type)
{
if (type == EventType.RENDER_TEXT)
{
TextRenderInfo renderInfo = (TextRenderInfo)data;
foreach (TextRenderInfo tri in renderInfo.GetCharacterRenderInfos())
{
base.EventOccurred(tri, type);
}
}
}
public virtual void EventOccurred(IEventData data, EventType type)
{
if (type.Equals(EventType.RENDER_TEXT))
{
TextRenderInfo renderInfo = (TextRenderInfo)data;
IList <TextRenderInfo> subs = renderInfo.GetCharacterRenderInfos();
for (int i = 0; i < subs.Count; i++)
{
TextRenderInfo charInfo = subs[i];
glyphWith = charInfo.GetBaseline().GetLength();
}
}
}
public virtual void RenderText(TextRenderInfo renderInfo)
{
IList <TextRenderInfo> subs = renderInfo.GetCharacterRenderInfos();
TextRenderInfo previousCharInfo = subs[0];
for (int i = 1; i < subs.Count; i++)
{
TextRenderInfo charInfo = subs[i];
Vector previousEndPoint = previousCharInfo.GetBaseline().GetEndPoint();
Vector currentStartPoint = charInfo.GetBaseline().GetStartPoint();
AssertVectorsEqual(previousEndPoint, currentStartPoint, charInfo.GetText());
previousCharInfo = charInfo;
}
}
public virtual void EventOccurred(IEventData data, EventType type)
{
if (type.Equals(EventType.RENDER_TEXT))
{
TextRenderInfo textRenderInfo = (TextRenderInfo)data;
foreach (TextRenderInfo glyphRenderInfo in textRenderInfo.GetCharacterRenderInfos())
{
delegate_.EventOccurred(glyphRenderInfo, type);
}
}
else
{
delegate_.EventOccurred(data, type);
}
}
public void RenderText(TextRenderInfo renderInfo)
{
var text = renderInfo.GetText();
var match = Regex.Match(text, _matchPattern);
if (match.Success)
{
var p1 = renderInfo.GetCharacterRenderInfos()[match.Index].GetAscentLine().GetStartPoint();
var p2 = renderInfo.GetCharacterRenderInfos()[match.Index + match.Length].GetAscentLine().GetEndPoint();
var p3 = renderInfo.GetCharacterRenderInfos()[match.Index + match.Length].GetDescentLine().GetEndPoint();
var p4 = renderInfo.GetCharacterRenderInfos()[match.Index].GetDescentLine().GetStartPoint();
_canvas.SaveState();
_canvas.SetColorStroke(BaseColor.BLACK);
_canvas.SetColorFill(BaseColor.BLACK);
_canvas.MoveTo(p1[Vector.I1], p1[Vector.I2]);
_canvas.LineTo(p2[Vector.I1], p2[Vector.I2]);
_canvas.LineTo(p3[Vector.I1], p3[Vector.I2]);
_canvas.LineTo(p4[Vector.I1], p4[Vector.I2]);
_canvas.ClosePathFillStroke();
_canvas.RestoreState();
}
}
public virtual void EventOccurred(IEventData data, EventType type)
{
if (type.Equals(EventType.RENDER_TEXT))
{
TextRenderInfo renderInfo = (TextRenderInfo)data;
IList <TextRenderInfo> subs = renderInfo.GetCharacterRenderInfos();
TextRenderInfo previousCharInfo = subs[0];
for (int i = 1; i < subs.Count; i++)
{
TextRenderInfo charInfo = subs[i];
Vector previousEndPoint = previousCharInfo.GetBaseline().GetEndPoint();
Vector currentStartPoint = charInfo.GetBaseline().GetStartPoint();
AssertVectorsEqual(charInfo.GetText(), previousEndPoint, currentStartPoint);
previousCharInfo = charInfo;
}
}
}
public void RenderText(TextRenderInfo renderInfo)
{
if (renderInfo.PdfString.ToUnicodeString().Length == 0)
{
return;
}
foreach (TextRenderInfo ri in renderInfo.GetCharacterRenderInfos())
{
bool textIsInsideRegion = TextIsInsideRegion(ri);
LineSegment baseline = ri.GetUnscaledBaseline();
chunks.Add(new PdfCleanUpContentChunk(ri.PdfString, baseline.GetStartPoint(), baseline.GetEndPoint(), !textIsInsideRegion, strNumber));
}
++strNumber;
}
public override void EventOccurred(IEventData data, EventType type)
{
if (!type.Equals(EventType.RENDER_TEXT))
{
return;
}
TextRenderInfo renderInfo = (TextRenderInfo)data;
string curFont = renderInfo.GetFont().GetFontProgram().ToString();
float curFontSize = renderInfo.GetFontSize();
IList <TextRenderInfo> text = renderInfo.GetCharacterRenderInfos();
foreach (TextRenderInfo t in text)
{
string letter = t.GetText();
Vector letterStart = t.GetDescentLine().GetStartPoint();
Vector letterEnd = t.GetAscentLine().GetEndPoint();
if (letter != " " && !letter.Contains(" "))
{
TextChar c = new TextChar();
chars.Add(c);
c.text = letter;
c.x1 = letterStart.Get(0);
c.x2 = letterEnd.Get(0);
c.y1 = letterStart.Get(1);
c.y2 = letterEnd.Get(1);
if (c.y1 > c.y2)
{
c.y1 = letterEnd.Get(1);
c.y2 = letterStart.Get(1);
}
c.fontFamily = curFont;
c.fontSize = curFontSize;
}
}
}
string RecalculateSpaces(TextRenderInfo textInfo)
{
var chars = textInfo.GetCharacterRenderInfos();
float charSize = (textInfo.GetUnscaledWidth() / chars.Count) / 2.0f;
StringBuilder sb = new StringBuilder();
foreach (var ch in chars)
{
string chText = ch.GetText();
if (chText != " " || (ch.GetUnscaledWidth() > charSize))
{
sb.Append(chText);
}
}
return(sb.ToString());
}
public override void RenderText(TextRenderInfo renderInfo)
{
base.RenderText(renderInfo);
List <TextChunk> tcs = new List <TextChunk>();
IList <TextRenderInfo> cris = renderInfo.GetCharacterRenderInfos();
foreach (TextRenderInfo cri in cris)
{
//Vector bottomLeft = cri.GetDescentLine().GetStartPoint();
Vector bottomLeft = cri.GetBaseline().GetStartPoint();
Vector topRight = cri.GetAscentLine().GetEndPoint();
TextChunk tc = new TextChunk(cri.GetText(), bottomLeft, topRight, cri.GetSingleSpaceWidth());
//TextChunks.Add(new TextChunk2(rect, renderInfo.GetText()));
tcs.Add(tc);
}
TextChunks.AddRange(tcs);
}
public virtual void EventOccurred(IEventData data, EventType type)
{
if (type.Equals(EventType.RENDER_TEXT))
{
TextRenderInfo renderInfo = (TextRenderInfo)data;
if (firstTextRenderInfo == null)
{
firstTextRenderInfo = renderInfo;
firstTextRenderInfo.PreserveGraphicsState();
}
IList <TextRenderInfo> subs = renderInfo.GetCharacterRenderInfos();
for (int i = 0; i < subs.Count; i++)
{
TextRenderInfo charInfo = subs[i];
glyphWidth = charInfo.GetBaseline().GetLength();
}
}
}
public virtual void RenderText(TextRenderInfo renderInfo)
{
if (renderInfo.PdfString.ToUnicodeString().Length == 0)
{
return;
}
foreach (TextRenderInfo ri in renderInfo.GetCharacterRenderInfos())
{
bool isAllowed = filter.AllowText(ri);
LineSegment baseline = ri.GetUnscaledBaseline();
chunks.Add(new PdfCleanUpContentChunk.Text(ri.PdfString, baseline.GetStartPoint(),
baseline.GetEndPoint(), isAllowed, strNumber));
}
++strNumber;
}
//Automatically called for each chunk of text in the PDF
public override void RenderText(TextRenderInfo renderInfo)
{
base.RenderText(renderInfo);
var chars = renderInfo.GetCharacterRenderInfos();
foreach (var c in chars)
{
//Console.Write(c.PdfString);
var startPoint = c.GetBaseline().GetStartPoint();
if (startPoint[0] > 400 && startPoint[0] < 480 && startPoint[1] > 842 - 128 && startPoint[1] < 848 - 110)
{
_text += c.PdfString;
}
}
}
/// <summary>Filter a TextRenderInfo object</summary>
/// <param name="text">the TextRenderInfo to be filtered</param>
public virtual PdfCleanUpFilter.FilterResult <PdfArray> FilterText(TextRenderInfo text)
{
PdfTextArray textArray = new PdfTextArray();
if (IsTextNotToBeCleaned(text))
{
return(new PdfCleanUpFilter.FilterResult <PdfArray>(false, new PdfArray(text.GetPdfString())));
}
foreach (TextRenderInfo ri in text.GetCharacterRenderInfos())
{
if (IsTextNotToBeCleaned(ri))
{
textArray.Add(ri.GetPdfString());
}
else
{
textArray.Add(new PdfNumber(-ri.GetUnscaledWidth() * 1000f / (text.GetFontSize() * text.GetHorizontalScaling
() / 100)));
}
}
return(new PdfCleanUpFilter.FilterResult <PdfArray>(true, textArray));
}
public override void RenderText(TextRenderInfo renderInfo)
{
base.RenderText(renderInfo);
// Get the current block of text.
var currentText = renderInfo.GetText();
// Compare the current block of text to our search text and get the start position.
var startPosition = CultureInfo.CurrentCulture.CompareInfo.IndexOf(currentText, this.SearchText, this.CompareOptions);
// If no start position or the current block does not match our search text, return silently.
// The second condition ensures that duplicate locations are not returned for
// very similar text values. For example: "1234" exists within the block
// of text "12345", but is not actually a match.
//
if (startPosition < 0 || currentText != SearchText)
{
return;
}
// Get the list of char values in the block of text.
var chars = renderInfo.GetCharacterRenderInfos().Skip(startPosition).Take(this.SearchText.Length).ToList();
// Select the first and last chars.
var firstChar = chars.First();
var lastChar = chars.Last();
// Get the two corner vectors of the rectangle containing the text.
var bottomLeft = firstChar.GetDescentLine().GetStartPoint();
var topRight = lastChar.GetAscentLine().GetEndPoint();
// Create a new rectangle instance from the vector data.
var rect = new Rectangle(bottomLeft[Vector.I1], bottomLeft[Vector.I2], topRight[Vector.I1], topRight[Vector.I2]);
// Create a new container instance and add it to the collection.
TextLocations.Add(new RectAndText(rect, this.SearchText));
//oh boy....
}
public override void EventOccurred(IEventData data, EventType type)
{
if (!type.Equals(EventType.RENDER_TEXT)) return;
TextRenderInfo renderInfo = (TextRenderInfo)data;
IList<TextRenderInfo> text = renderInfo.GetCharacterRenderInfos();
foreach (TextRenderInfo t in text)
{
string letter = t.GetText();
Vector letterStart = t.GetBaseline().GetStartPoint();
Vector letterEnd = t.GetAscentLine().GetEndPoint();
Rectangle letterRect = new Rectangle(letterStart.Get(0), letterStart.Get(1), letterEnd.Get(0) - letterStart.Get(0), letterEnd.Get(1) - letterStart.Get(1));
TextMyChunk chunk = new TextMyChunk();
chunk.Text = letter;
chunk.Rect = letterRect;
chunk.FontFamily = t.GetFont().GetFontProgram().ToString();
chunk.FontSize = t.GetFontSize();
chunk.SpaceWidth = t.GetSingleSpaceWidth();
objectResult.Add(chunk);
}
}
public override void EventOccurred(IEventData data, EventType type)
{
if (!type.Equals(EventType.RENDER_TEXT))
{
return;
}
TextRenderInfo renderInfo = (TextRenderInfo)data;
float counter = increaseCounter();
var font = renderInfo.GetFont().GetFontProgram();
var originalFontName = font.ToString();
var fontRegex = Regex.Match(originalFontName, @"(?<=\+)[a-zA-Z\s]+");
string fontName = fontRegex.Success ? fontRegex.Value : originalFontName;
var fontStyle = font.GetFontNames().GetFontStyle();
float curFontSize = renderInfo.GetFontSize();
float key = counter;
IList <TextRenderInfo> text = renderInfo.GetCharacterRenderInfos();
foreach (TextRenderInfo character in text)
{
key += 0.001f;
var textRenderMode = character.GetTextRenderMode();
var opacity = character.GetGraphicsState().GetFillOpacity();
//if (textRenderMode != 0 || opacity != 1)
//{
//}
string letter = character.GetText();
Color color;
var fillColor = character.GetFillColor();
var colors = fillColor.GetColorValue();
if (colors.Length == 1)
{
color = Color.FromArgb((int)(255 * (1 - colors[0])), Color.Black);
}
else if (colors.Length == 3)
{
color = Color.FromArgb((int)(255 * colors[0]), (int)(255 * colors[1]), (int)(255 * colors[2]));
}
else if (colors.Length == 4)
{
color = Color.FromArgb((int)(255 * colors[0]), (int)(255 * colors[1]), (int)(255 * colors[2]), (int)(255 * colors[3]));
}
else
{
color = Color.Black;
}
//if(letter == "A")
//{
//}
if (string.IsNullOrWhiteSpace(letter))
{
continue;
}
//Get the bounding box for the chunk of text
var bottomLeft = character.GetDescentLine().GetStartPoint();
var topRight = character.GetAscentLine().GetEndPoint();
//Create a rectangle from it
var rect = new Geom.Rectangle(
bottomLeft.Get(Vector.I1),
topRight.Get(Vector.I2),
topRight.Get(Vector.I1),
topRight.Get(Vector.I2)
);
var currentChunk = new itext.pdfimage.Models.TextChunk()
{
Text = letter,
Rect = rect,
FontFamily = fontName,
FontSize = (int)curFontSize,
FontStyle = fontStyle,
Color = color,
SpaceWidth = character.GetSingleSpaceWidth() / 2f
};
chunkDictionairy.Add(key, currentChunk);
}
base.EventOccurred(data, type);
}
virtual public void RenderText(TextRenderInfo renderInfo) {
foreach (TextRenderInfo glyphInfo in renderInfo.GetCharacterRenderInfos())
deleg.RenderText(glyphInfo);
}
public override void RenderText(TextRenderInfo renderInfo)
{
base.RenderText(renderInfo);
LineSegment baseline = renderInfo.GetBaseline();
//Create ExtendedChunk
ExtendedTextChunk aExtendedChunk = new ExtendedTextChunk(renderInfo.GetText(), baseline.GetStartPoint(), baseline.GetEndPoint(), renderInfo.GetSingleSpaceWidth(), renderInfo.GetCharacterRenderInfos().ToList());
this.m_DocChunks.Add(aExtendedChunk);
}
