PdfLine defines an array with PdfChunk-objects
* that fit into 1 line.
*/
public class PdfLine {
// membervariables
/** The arraylist containing the chunks. */
protected internal ArrayList line;
/** The left indentation of the line. */
protected internal float left;
/** The width of the line. */
protected internal float width;
/** The alignment of the line. */
protected internal int alignment;
/** The heigth of the line. */
protected internal float height;
/** The listsymbol (if necessary). */
protected internal Chunk listSymbol = null;
/** The listsymbol (if necessary). */
protected internal float symbolIndent;
/** true if the chunk splitting was caused by a newline. */
protected internal bool newlineSplit = false;
/** The original width. */
protected internal float originalWidth;
protected internal bool isRTL = false;
// constructors
/**
* Constructs a new PdfLine-object.
*
* @param left the limit of the line at the left
* @param right the limit of the line at the right
* @param alignment the alignment of the line
* @param height the height of the line
*/
internal PdfLine(float left, float right, int alignment, float height) {
this.left = left;
this.width = right - left;
this.originalWidth = this.width;
this.alignment = alignment;
this.height = height;
this.line = new ArrayList();
}
/**
* Creates a PdfLine object.
* @param left the left offset
* @param originalWidth the original width of the line
* @param remainingWidth bigger than 0 if the line isn't completely filled
* @param alignment the alignment of the line
* @param newlineSplit was the line splitted (or does the paragraph end with this line)
* @param line an array of PdfChunk objects
* @param isRTL do you have to read the line from Right to Left?
*/
internal PdfLine(float left, float originalWidth, float remainingWidth, int alignment, bool newlineSplit, ArrayList line, bool isRTL) {
this.left = left;
this.originalWidth = originalWidth;
this.width = remainingWidth;
this.alignment = alignment;
this.line = line;
this.newlineSplit = newlineSplit;
this.isRTL = isRTL;
}
// methods
/**
* Adds a PdfChunk to the PdfLine.
*
* @param chunk the PdfChunk to add
* @return null if the chunk could be added completely; if not
* a PdfChunk containing the part of the chunk that could
* not be added is returned
*/
internal PdfChunk Add(PdfChunk chunk) {
// nothing happens if the chunk is null.
if (chunk == null || chunk.ToString().Equals("")) {
return null;
}
// we split the chunk to be added
PdfChunk overflow = chunk.Split(width);
newlineSplit = (chunk.IsNewlineSplit() || overflow == null);
// if (chunk.IsNewlineSplit() && alignment == Element.ALIGN_JUSTIFIED)
// alignment = Element.ALIGN_LEFT;
if (chunk.IsTab()) {
Object[] tab = (Object[])chunk.GetAttribute(Chunk.TAB);
float tabPosition = (float)tab[1];
bool newline = (bool)tab[2];
if (newline && tabPosition < originalWidth - width) {
return chunk;
}
width = originalWidth - tabPosition;
chunk.AdjustLeft(left);
AddToLine(chunk);
}
// if the length of the chunk > 0 we add it to the line
else if (chunk.Length > 0) {
if (overflow != null)
chunk.TrimLastSpace();
width -= chunk.Width;
AddToLine(chunk);
}
// if the length == 0 and there were no other chunks added to the line yet,
// we risk to end up in an endless loop trying endlessly to add the same chunk
else if (line.Count < 1) {
chunk = overflow;
overflow = chunk.Truncate(width);
width -= chunk.Width;
if (chunk.Length > 0) {
AddToLine(chunk);
return overflow;
}
// if the chunck couldn't even be truncated, we add everything, so be it
else {
if (overflow != null)
AddToLine(chunk);
return null;
}
}
else {
width += ((PdfChunk)(line[line.Count - 1])).TrimLastSpace();
}
return overflow;
}
private void AddToLine(PdfChunk chunk) {
if (chunk.ChangeLeading && chunk.IsImage()) {
float f = chunk.Image.ScaledHeight + chunk.ImageOffsetY;
if (f > height) height = f;
}
line.Add(chunk);
}
// methods to retrieve information
/**
* Returns the number of chunks in the line.
*
* @return a value
*/
public int Size {
get {
return line.Count;
}
}
/**
* Returns an iterator of PdfChunks.
*
* @return an Iterator
*/
public IEnumerator GetEnumerator() {
return line.GetEnumerator();
}
/**
* Returns the height of the line.
*
* @return a value
*/
internal float Height {
get {
return height;
}
}
/**
* Returns the left indentation of the line taking the alignment of the line into account.
*
* @return a value
*/
internal float IndentLeft {
get {
if (isRTL) {
switch (alignment) {
case Element.ALIGN_LEFT:
return left + width;
case Element.ALIGN_CENTER:
return left + (width / 2f);
default:
return left;
}
}
else {
switch (alignment) {
case Element.ALIGN_RIGHT:
return left + width;
case Element.ALIGN_CENTER:
return left + (width / 2f);
default:
return left;
}
}
}
}
/**
* Checks if this line has to be justified.
*
* @return true if the alignment equals ALIGN_JUSTIFIED and there is some width left.
*/
public bool HasToBeJustified() {
return ((alignment == Element.ALIGN_JUSTIFIED || alignment == Element.ALIGN_JUSTIFIED_ALL) && width != 0);
}
/**
* Resets the alignment of this line.
*
* The alignment of the last line of for instance a Paragraph
* that has to be justified, has to be reset to ALIGN_LEFT.
*/
public void ResetAlignment() {
if (alignment == Element.ALIGN_JUSTIFIED) {
alignment = Element.ALIGN_LEFT;
}
}
/** Adds extra indentation to the left (for Paragraph.setFirstLineIndent). */
internal void SetExtraIndent(float extra) {
left += extra;
width -= extra;
}
/**
* Returns the width that is left, after a maximum of characters is added to the line.
*
* @return a value
*/
internal float WidthLeft {
get {
return width;
}
}
/**
* Returns the number of space-characters in this line.
*
* @return a value
*/
internal int NumberOfSpaces {
get {
string str = ToString();
int length = str.Length;
int numberOfSpaces = 0;
for (int i = 0; i < length; i++) {
if (str[i] == ' ') {
numberOfSpaces++;
}
}
return numberOfSpaces;
}
}
/**
* Sets the listsymbol of this line.
*
* This is only necessary for the first line of a ListItem.
*
* @param listItem the list symbol
*/
public ListItem ListItem {
set {
this.listSymbol = value.ListSymbol;
this.symbolIndent = value.IndentationLeft;
}
}
/**
* Returns the listsymbol of this line.
*
* @return a PdfChunk if the line has a listsymbol; null otherwise
*/
public Chunk ListSymbol {
get {
return listSymbol;
}
}
/**
* Return the indentation needed to show the listsymbol.
*
* @return a value
*/
public float ListIndent {
get {
return symbolIndent;
}
}
/**
* Get the string representation of what is in this line.
*
* @return a string
*/
public override string ToString() {
StringBuilder tmp = new StringBuilder();
foreach (PdfChunk c in line) {
tmp.Append(c.ToString());
}
return tmp.ToString();
}
public int GetLineLengthUtf32() {
int total = 0;
foreach (PdfChunk c in line) {
total += c.LengthUtf32;
}
return total;
}
/**
* Checks if a newline caused the line split.
* @return true if a newline caused the line split
*/
public bool NewlineSplit {
get {
return newlineSplit && (alignment != Element.ALIGN_JUSTIFIED_ALL);
}
}
/**
* Gets the index of the last PdfChunk with metric attributes
* @return the last PdfChunk with metric attributes
*/
public int LastStrokeChunk {
get {
int lastIdx = line.Count - 1;
for (; lastIdx >= 0; --lastIdx) {
PdfChunk chunk = (PdfChunk)line[lastIdx];
if (chunk.IsStroked())
break;
}
return lastIdx;
}
}
/**
* Gets a PdfChunk by index.
* @param idx the index
* @return the PdfChunk or null if beyond the array
*/
public PdfChunk GetChunk(int idx) {
if (idx < 0 || idx >= line.Count)
return null;
return (PdfChunk)line[idx];
}
/**
* Gets the original width of the line.
* @return the original width of the line
*/
public float OriginalWidth {
get {
return originalWidth;
}
}
/**
* Gets the maximum size of all the fonts used in this line
* including images.
* @return maximum size of all the fonts used in this line
*/
internal float MaxSizeSimple {
get {
float maxSize = 0;
for (int k = 0; k < line.Count; ++k) {
PdfChunk chunk = (PdfChunk)line[k];
if (!chunk.IsImage()) {
maxSize = Math.Max(chunk.Font.Size, maxSize);
}
else {
maxSize = Math.Max(chunk.Image.ScaledHeight + chunk.ImageOffsetY , maxSize);
}
}
return maxSize;
}
}
internal bool RTL {
get {
return isRTL;
}
}
/**
* Gets the number of separators in the line.
* @return the number of separators in the line
* @since 2.1.2
*/
internal int GetSeparatorCount() {
int s = 0;
foreach (PdfChunk ck in line) {
if (ck.IsTab()) {
return 0;
}
if (ck.IsHorizontalSeparator()) {
s++;
}
}
return s;
}
public float GetWidthCorrected(float charSpacing, float wordSpacing) {
float total = 0;
for (int k = 0; k < line.Count; ++k) {
PdfChunk ck = (PdfChunk)line[k];
total += ck.GetWidthCorrected(charSpacing, wordSpacing);
}
return total;
}
/**
* Gets the maximum size of the ascender for all the fonts used
* in this line.
* @return maximum size of all the ascenders used in this line
*/
public float Ascender {
get {
float ascender = 0;
foreach (PdfChunk ck in line) {
if (ck.IsImage())
ascender = Math.Max(ascender, ck.Image.ScaledHeight + ck.ImageOffsetY);
else {
PdfFont font = ck.Font;
ascender = Math.Max(ascender, font.Font.GetFontDescriptor(BaseFont.ASCENT, font.Size));
}
}
return ascender;
}
}
/**
* Gets the biggest descender for all the fonts used
* in this line. Note that this is a negative number.
* @return maximum size of all the ascenders used in this line
*/
public float Descender {
get {
float descender = 0;
foreach (PdfChunk ck in line) {
if (ck.IsImage())
descender = Math.Min(descender, ck.ImageOffsetY);
else {
PdfFont font = ck.Font;
descender = Math.Min(descender, font.Font.GetFontDescriptor(BaseFont.DESCENT, font.Size));
}
}
return descender;
}
}
}
}