/**
* Constructs a <CODE>PdfOutline</CODE>.
* <P>
* This is the constructor for an <CODE>outline entry</CODE>.
*
* @param parent the parent of this outline item
* @param destination the destination for this outline item
* @param title the title of this outline item
* @param open <CODE>true</CODE> if the children are visible
*/
public PdfOutline(PdfOutline parent, PdfDestination destination, Paragraph title, bool open)
: base()
{
StringBuilder buf = new StringBuilder();
foreach (Chunk chunk in title.Chunks) {
buf.Append(chunk.Content);
}
this.destination = destination;
InitOutline(parent, buf.ToString(), open);
}
// constructors
/**
* Constructs a <CODE>PdfOutline</CODE>.
* <P>
* This is the constructor for the <CODE>outlines object</CODE>.
*/
internal PdfOutline(PdfWriter writer)
: base(OUTLINES)
{
open = true;
parent = null;
this.writer = writer;
}
/**
* Constructs a <CODE>PdfOutline</CODE>.
* <P>
* This is the constructor for an <CODE>outline entry</CODE>. The open mode is
* <CODE>true</CODE>.
*
* @param parent the parent of this outline item
* @param action the <CODE>PdfAction</CODE> for this outline item
* @param title the title of this outline item
*/
public PdfOutline(PdfOutline parent, PdfAction action, Paragraph title)
: this(parent, action, title, true)
{
}
/**
* Constructs a <CODE>PdfOutline</CODE>.
* <P>
* This is the constructor for an <CODE>outline entry</CODE>. The open mode is
* <CODE>true</CODE>.
*
* @param parent the parent of this outline item
* @param destination the destination for this outline item
* @param title the title of this outline item
*/
public PdfOutline(PdfOutline parent, PdfDestination destination, Paragraph title)
: this(parent, destination, title, true)
{
}
/**
* Constructs a <CODE>PdfOutline</CODE>.
* <P>
* This is the constructor for an <CODE>outline entry</CODE>. The open mode is
* <CODE>true</CODE>.
*
* @param parent the parent of this outline item
* @param destination the destination for this outline item
* @param title the title of this outline item
*/
public PdfOutline(PdfOutline parent, PdfDestination destination, PdfString title)
: this(parent, destination, title, true)
{
}
/**
* Constructs a <CODE>PdfOutline</CODE>.
* <P>
* This is the constructor for an <CODE>outline entry</CODE>.
*
* @param parent the parent of this outline item
* @param destination the destination for this outline item
* @param title the title of this outline item
* @param open <CODE>true</CODE> if the children are visible
*/
public PdfOutline(PdfOutline parent, PdfDestination destination, PdfString title, bool open)
: this(parent, destination, title.ToString(), true)
{
}
/**
* Constructs a <CODE>PdfOutline</CODE>.
* <P>
* This is the constructor for an <CODE>outline entry</CODE>. The open mode is
* <CODE>true</CODE>.
*
* @param parent the parent of this outline item
* @param action the <CODE>PdfAction</CODE> for this outline item
* @param title the title of this outline item
*/
public PdfOutline(PdfOutline parent, PdfAction action, PdfString title)
: this(parent, action, title, true)
{
}
/**
* Adds a named outline to the document .
* @param outline the outline to be added
* @param name the name of this local destination
*/
internal void AddOutline(PdfOutline outline, String name)
{
LocalDestination(name, outline.PdfDestination);
}
/**
* Constructs a <CODE>PdfOutline</CODE>.
* <P>
* This is the constructor for an <CODE>outline entry</CODE>.
*
* @param parent the parent of this outline item
* @param action the <CODE>PdfAction</CODE> for this outline item
* @param title the title of this outline item
* @param open <CODE>true</CODE> if the children are visible
*/
public PdfOutline(PdfOutline parent, PdfAction action, string title, bool open)
: base()
{
this.action = action;
InitOutline(parent, title, open);
}
/**
* Constructs a <CODE>PdfOutline</CODE>.
* <P>
* This is the constructor for an <CODE>outline entry</CODE>.
*
* @param parent the parent of this outline item
* @param destination the destination for this outline item
* @param title the title of this outline item
* @param open <CODE>true</CODE> if the children are visible
*/
public PdfOutline(PdfOutline parent, PdfDestination destination, string title, bool open)
: base()
{
this.destination = destination;
InitOutline(parent, title, open);
}
/**
* Signals that an <CODE>Element</CODE> was added to the <CODE>Document</CODE>.
*
* @param element the element to add
* @return <CODE>true</CODE> if the element was added, <CODE>false</CODE> if not.
* @throws DocumentException when a document isn't open yet, or has been closed
*/
public override bool Add(IElement element)
{
if (writer != null && writer.IsPaused()) {
return false;
}
switch (element.Type) {
// Information (headers)
case Element.HEADER:
info.Addkey(((Meta)element).Name, ((Meta)element).Content);
break;
case Element.TITLE:
info.AddTitle(((Meta)element).Content);
break;
case Element.SUBJECT:
info.AddSubject(((Meta)element).Content);
break;
case Element.KEYWORDS:
info.AddKeywords(((Meta)element).Content);
break;
case Element.AUTHOR:
info.AddAuthor(((Meta)element).Content);
break;
case Element.CREATOR:
info.AddCreator(((Meta)element).Content);
break;
case Element.PRODUCER:
// you can not change the name of the producer
info.AddProducer();
break;
case Element.CREATIONDATE:
// you can not set the creation date, only reset it
info.AddCreationDate();
break;
// content (text)
case Element.CHUNK: {
// if there isn't a current line available, we make one
if (line == null) {
CarriageReturn();
}
// we cast the element to a chunk
PdfChunk chunk = new PdfChunk((Chunk) element, anchorAction);
// we try to add the chunk to the line, until we succeed
{
PdfChunk overflow;
while ((overflow = line.Add(chunk)) != null) {
CarriageReturn();
chunk = overflow;
chunk.TrimFirstSpace();
}
}
pageEmpty = false;
if (chunk.IsAttribute(Chunk.NEWPAGE)) {
NewPage();
}
break;
}
case Element.ANCHOR: {
leadingCount++;
Anchor anchor = (Anchor) element;
String url = anchor.Reference;
leading = anchor.Leading;
if (url != null) {
anchorAction = new PdfAction(url);
}
// we process the element
element.Process(this);
anchorAction = null;
leadingCount--;
break;
}
case Element.ANNOTATION: {
if (line == null) {
CarriageReturn();
}
Annotation annot = (Annotation) element;
Rectangle rect = new Rectangle(0, 0);
if (line != null)
rect = new Rectangle(annot.GetLlx(IndentRight - line.WidthLeft), annot.GetLly(IndentTop - currentHeight), annot.GetUrx(IndentRight - line.WidthLeft + 20), annot.GetUry(IndentTop - currentHeight - 20));
PdfAnnotation an = PdfAnnotationsImp.ConvertAnnotation(writer, annot, rect);
annotationsImp.AddPlainAnnotation(an);
pageEmpty = false;
break;
}
case Element.PHRASE: {
leadingCount++;
// we cast the element to a phrase and set the leading of the document
leading = ((Phrase) element).Leading;
// we process the element
element.Process(this);
leadingCount--;
break;
}
case Element.PARAGRAPH: {
leadingCount++;
// we cast the element to a paragraph
Paragraph paragraph = (Paragraph) element;
AddSpacing(paragraph.SpacingBefore, leading, paragraph.Font);
// we adjust the parameters of the document
alignment = paragraph.Alignment;
leading = paragraph.TotalLeading;
CarriageReturn();
// we don't want to make orphans/widows
if (currentHeight + line.Height + leading > IndentTop - IndentBottom) {
NewPage();
}
indentation.indentLeft += paragraph.IndentationLeft;
indentation.indentRight += paragraph.IndentationRight;
CarriageReturn();
IPdfPageEvent pageEvent = writer.PageEvent;
if (pageEvent != null && !isSectionTitle)
pageEvent.OnParagraph(writer, this, IndentTop - currentHeight);
// if a paragraph has to be kept together, we wrap it in a table object
if (paragraph.KeepTogether) {
CarriageReturn();
PdfPTable table = new PdfPTable(1);
table.WidthPercentage = 100f;
PdfPCell cell = new PdfPCell();
cell.AddElement(paragraph);
cell.Border = Rectangle.NO_BORDER;
cell.Padding = 0;
table.AddCell(cell);
indentation.indentLeft -= paragraph.IndentationLeft;
indentation.indentRight -= paragraph.IndentationRight;
this.Add(table);
indentation.indentLeft += paragraph.IndentationLeft;
indentation.indentRight += paragraph.IndentationRight;
}
else {
line.SetExtraIndent(paragraph.FirstLineIndent);
element.Process(this);
CarriageReturn();
AddSpacing(paragraph.SpacingAfter, paragraph.TotalLeading, paragraph.Font);
}
if (pageEvent != null && !isSectionTitle)
pageEvent.OnParagraphEnd(writer, this, IndentTop - currentHeight);
alignment = Element.ALIGN_LEFT;
indentation.indentLeft -= paragraph.IndentationLeft;
indentation.indentRight -= paragraph.IndentationRight;
CarriageReturn();
leadingCount--;
break;
}
case Element.SECTION:
case Element.CHAPTER: {
// Chapters and Sections only differ in their constructor
// so we cast both to a Section
Section section = (Section) element;
IPdfPageEvent pageEvent = writer.PageEvent;
bool hasTitle = section.NotAddedYet && section.Title != null;
// if the section is a chapter, we begin a new page
if (section.TriggerNewPage) {
NewPage();
}
if (hasTitle) {
float fith = IndentTop - currentHeight;
int rotation = pageSize.Rotation;
if (rotation == 90 || rotation == 180)
fith = pageSize.Height - fith;
PdfDestination destination = new PdfDestination(PdfDestination.FITH, fith);
while (currentOutline.Level >= section.Depth) {
currentOutline = currentOutline.Parent;
}
PdfOutline outline = new PdfOutline(currentOutline, destination, section.GetBookmarkTitle(), section.BookmarkOpen);
currentOutline = outline;
}
// some values are set
CarriageReturn();
indentation.sectionIndentLeft += section.IndentationLeft;
indentation.sectionIndentRight += section.IndentationRight;
if (section.NotAddedYet && pageEvent != null)
if (element.Type == Element.CHAPTER)
pageEvent.OnChapter(writer, this, IndentTop - currentHeight, section.Title);
else
pageEvent.OnSection(writer, this, IndentTop - currentHeight, section.Depth, section.Title);
// the title of the section (if any has to be printed)
if (hasTitle) {
isSectionTitle = true;
Add(section.Title);
isSectionTitle = false;
}
indentation.sectionIndentLeft += section.Indentation;
// we process the section
element.Process(this);
// some parameters are set back to normal again
indentation.sectionIndentLeft -= (section.IndentationLeft + section.Indentation);
indentation.sectionIndentRight -= section.IndentationRight;
if (section.ElementComplete && pageEvent != null)
if (element.Type == Element.CHAPTER)
pageEvent.OnChapterEnd(writer, this, IndentTop - currentHeight);
else
pageEvent.OnSectionEnd(writer, this, IndentTop - currentHeight);
break;
}
case Element.LIST: {
// we cast the element to a List
List list = (List) element;
if (list.Alignindent) {
list.NormalizeIndentation();
}
// we adjust the document
indentation.listIndentLeft += list.IndentationLeft;
indentation.indentRight += list.IndentationRight;
// we process the items in the list
element.Process(this);
// some parameters are set back to normal again
indentation.listIndentLeft -= list.IndentationLeft;
indentation.indentRight -= list.IndentationRight;
CarriageReturn();
break;
}
case Element.LISTITEM: {
leadingCount++;
// we cast the element to a ListItem
ListItem listItem = (ListItem) element;
AddSpacing(listItem.SpacingBefore, leading, listItem.Font);
// we adjust the document
alignment = listItem.Alignment;
indentation.listIndentLeft += listItem.IndentationLeft;
indentation.indentRight += listItem.IndentationRight;
leading = listItem.TotalLeading;
CarriageReturn();
// we prepare the current line to be able to show us the listsymbol
line.ListItem = listItem;
// we process the item
element.Process(this);
AddSpacing(listItem.SpacingAfter, listItem.TotalLeading, listItem.Font);
// if the last line is justified, it should be aligned to the left
if (line.HasToBeJustified()) {
line.ResetAlignment();
}
// some parameters are set back to normal again
CarriageReturn();
indentation.listIndentLeft -= listItem.IndentationLeft;
indentation.indentRight -= listItem.IndentationRight;
leadingCount--;
break;
}
case Element.RECTANGLE: {
Rectangle rectangle = (Rectangle) element;
graphics.Rectangle(rectangle);
pageEmpty = false;
break;
}
case Element.PTABLE: {
PdfPTable ptable = (PdfPTable)element;
if (ptable.Size <= ptable.HeaderRows)
break; //nothing to do
// before every table, we add a new line and flush all lines
EnsureNewLine();
FlushLines();
AddPTable(ptable);
pageEmpty = false;
NewLine();
break;
}
case Element.MULTI_COLUMN_TEXT: {
EnsureNewLine();
FlushLines();
MultiColumnText multiText = (MultiColumnText) element;
float height = multiText.Write(writer.DirectContent, this, IndentTop - currentHeight);
currentHeight += height;
text.MoveText(0, -1f* height);
pageEmpty = false;
break;
}
case Element.TABLE : {
if (element is SimpleTable) {
PdfPTable ptable = ((SimpleTable)element).CreatePdfPTable();
if (ptable.Size <= ptable.HeaderRows)
break; //nothing to do
// before every table, we add a new line and flush all lines
EnsureNewLine();
FlushLines();
AddPTable(ptable);
pageEmpty = false;
break;
} else if (element is Table) {
try {
PdfPTable ptable = ((Table)element).CreatePdfPTable();
if (ptable.Size <= ptable.HeaderRows)
break; //nothing to do
// before every table, we add a new line and flush all lines
EnsureNewLine();
FlushLines();
AddPTable(ptable);
pageEmpty = false;
break;
}
catch (BadElementException) {
// constructing the PdfTable
// Before the table, add a blank line using offset or default leading
float offset = ((Table)element).Offset;
if (float.IsNaN(offset))
offset = leading;
CarriageReturn();
lines.Add(new PdfLine(IndentLeft, IndentRight, alignment, offset));
currentHeight += offset;
AddPdfTable((Table)element);
}
} else {
return false;
}
break;
}
case Element.JPEG:
case Element.JPEG2000:
case Element.JBIG2:
case Element.IMGRAW:
case Element.IMGTEMPLATE: {
//carriageReturn(); suggestion by Marc Campforts
Add((Image) element);
break;
}
case Element.YMARK: {
IDrawInterface zh = (IDrawInterface)element;
zh.Draw(graphics, IndentLeft, IndentBottom, IndentRight, IndentTop, IndentTop - currentHeight - (leadingCount > 0 ? leading : 0));
pageEmpty = false;
break;
}
case Element.MARKED: {
MarkedObject mo;
if (element is MarkedSection) {
mo = ((MarkedSection)element).Title;
if (mo != null) {
mo.Process(this);
}
}
mo = (MarkedObject)element;
mo.Process(this);
break;
}
default:
return false;
}
lastElementType = element.Type;
return true;
}
internal void TraverseOutlineCount(PdfOutline outline)
{
ArrayList kids = outline.Kids;
PdfOutline parent = outline.Parent;
if (kids.Count == 0) {
if (parent != null) {
parent.Count = parent.Count + 1;
}
}
else {
for (int k = 0; k < kids.Count; ++k) {
TraverseOutlineCount((PdfOutline)kids[k]);
}
if (parent != null) {
if (outline.Open) {
parent.Count = outline.Count + parent.Count + 1;
}
else {
parent.Count = parent.Count + 1;
outline.Count = -outline.Count;
}
}
}
}
internal void OutlineTree(PdfOutline outline)
{
outline.IndirectReference = writer.PdfIndirectReference;
if (outline.Parent != null)
outline.Put(PdfName.PARENT, outline.Parent.IndirectReference);
ArrayList kids = outline.Kids;
int size = kids.Count;
for (int k = 0; k < size; ++k)
OutlineTree((PdfOutline)kids[k]);
for (int k = 0; k < size; ++k) {
if (k > 0)
((PdfOutline)kids[k]).Put(PdfName.PREV, ((PdfOutline)kids[k - 1]).IndirectReference);
if (k < size - 1)
((PdfOutline)kids[k]).Put(PdfName.NEXT, ((PdfOutline)kids[k + 1]).IndirectReference);
}
if (size > 0) {
outline.Put(PdfName.FIRST, ((PdfOutline)kids[0]).IndirectReference);
outline.Put(PdfName.LAST, ((PdfOutline)kids[size - 1]).IndirectReference);
}
for (int k = 0; k < size; ++k) {
PdfOutline kid = (PdfOutline)kids[k];
writer.AddToBody(kid, kid.IndirectReference);
}
}
public void AddKid(PdfOutline outline)
{
kids.Add(outline);
}
/**
* Constructs a <CODE>PdfOutline</CODE>.
* <P>
* This is the constructor for an <CODE>outline entry</CODE>.
*
* @param parent the parent of this outline item
* @param action the <CODE>PdfAction</CODE> for this outline item
* @param title the title of this outline item
* @param open <CODE>true</CODE> if the children are visible
*/
public PdfOutline(PdfOutline parent, PdfAction action, PdfString title, bool open)
: this(parent, action, title.ToString(), open)
{
}
// methods
/** Helper for the constructors.
* @param parent the parent outline
* @param title the title for this outline
* @param open <CODE>true</CODE> if the children are visible
*/
internal void InitOutline(PdfOutline parent, string title, bool open)
{
this.open = open;
this.parent = parent;
writer = parent.writer;
Put(PdfName.TITLE, new PdfString(title, PdfObject.TEXT_UNICODE));
parent.AddKid(this);
if (destination != null && !destination.HasPage()) // bugfix Finn Bock
SetDestinationPage(writer.CurrentPage);
}
// [L1] DocListener interface
/**
* Opens the document.
* <P>
* You have to open the document before you can begin to add content
* to the body of the document.
*/
public override void Open()
{
if (!open) {
base.Open();
writer.Open();
rootOutline = new PdfOutline(writer);
currentOutline = rootOutline;
}
InitPage();
}