//
// methods
//
public virtual PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
{
if (this.IsEmpty())
{
if (context.ShouldLogMessage)
{
context.TraceLog.Add(TraceLevel.Message, "Viewer Preferences", "No values set on the document viewer preferences so not outputting");
}
return(null);
}
else
{
PDFObjectRef oref = writer.BeginObject();
writer.BeginDictionary();
this.WriteOptionalFlag("CenterWindow", _centrewindow, context, writer);
this.WriteOptionalFlag("FitWindow", _fitwindow, context, writer);
this.WriteOptionalFlag("HideWindowUI", _hidewindowui, context, writer);
this.WriteOptionalFlag("HideToolbar", _hidetoolbar, context, writer);
this.WriteOptionalFlag("HideMenubar", _hidemenubar, context, writer);
if (this.NonFullScreenPageDisplay != PageDisplayMode.Undefined)
{
this.WriteOptionalName("NonFullScreenPageMode", this.NonFullScreenPageDisplay.ToString(), context, writer);
}
writer.EndDictionary();
writer.EndObject();
return(oref);
}
}
//
// methods
//
#region public virtual PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer) + Support methods
/// <summary>
/// Outputs this Info to the current writer
/// </summary>
/// <param name="context"></param>
/// <param name="writer"></param>
/// <returns></returns>
public virtual PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
{
PDFObjectRef inforef = writer.BeginObject("Info");
writer.BeginDictionary();
OutputInfoEntry("Title", this.Title, writer);
OutputInfoEntry("Subject", this.Subject, writer);
OutputInfoEntry("Author", this.Author, writer);
OutputInfoEntry("Keywords", this.Keywords, writer);
OutputInfoEntry("Producer", this.Producer, writer);
OutputInfoEntry("Creator", this.Creator, writer);
OutputInfoEntry("CreationDate", this.CreationDate, writer);
OutputInfoEntry("ModDate", this.ModifiedDate, writer);
if (this.HasTrapping)
{
writer.WriteDictionaryNameEntry("Trapped", this.Trapped.ToString());
}
if (this.HasExtras)
{
foreach (PDFDocumentInfoExtra extra in this.Extras)
{
OutputInfoEntry(extra.Name, extra.Value, writer);
}
}
writer.EndDictionary();
writer.EndObject();
return(inforef);
}
public PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
{
if (this.Fields.Count > 0)
{
PDFObjectRef parent = writer.BeginObject();
List <PDFObjectRef> children = new List <PDFObjectRef>();
foreach (var fld in this.Fields)
{
var child = fld.OutputToPDF(context, writer);
if (null != child)
{
children.Add(child);
}
}
writer.BeginDictionary();
writer.WriteDictionaryStringEntry("T", this.Name);
writer.BeginDictionaryEntry("Kids");
writer.WriteArrayRefEntries(true, children.ToArray());
writer.EndDictionaryEntry();
writer.EndDictionary();
writer.EndObject();
return(parent);
}
return(null);
}
/// <summary>
/// Outputs the first Page tree Component and calls Output on each of the layout pages.
/// </summary>
/// <param name="context">The current context</param>
/// <param name="writer">The current writer</param>
/// <returns>A reference to the current page tree root Component</returns>
protected virtual PDFObjectRef OutputPageTree(PDFRenderContext context, PDFWriter writer)
{
//Begin the Pages object and dictionary
PDFObjectRef pgs = writer.BeginObject(Const.PageTreeName);
writer.BeginDictionary();
writer.WriteDictionaryNameEntry("Type", "Pages");
List <PDFObjectRef> pagerefs = OutputAllPages(pgs, context, writer);
//write the kids array entry in the dictionary
writer.BeginDictionaryEntry("Kids");
writer.BeginArray();
foreach (PDFObjectRef kid in pagerefs)
{
writer.BeginArrayEntry();
writer.WriteFileObject(kid);
writer.EndArrayEntry();
}
writer.EndArray();
//Write the total number of pages to the dictionary
writer.EndDictionaryEntry();
writer.BeginDictionaryEntry("Count");
writer.WriteNumber(pagerefs.Count);
writer.EndDictionaryEntry();
//close the ditionary and the object
writer.EndDictionary();
writer.EndObject();
return(pgs);
}
public PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
{
if (context.ShouldLogDebug)
{
context.TraceLog.Begin(TraceLevel.Verbose, "Annotation Collection", "Outputting the doument annotations to the writer");
}
PDFObjectRef annot = writer.BeginObject();
List <PDFObjectRef> entries = new List <PDFObjectRef>();
//TODO:Render annotations
foreach (PDFAnnotationEntry entry in this._annots)
{
PDFObjectRef oref = entry.OutputToPDF(context, writer);
if (oref != null)
{
entries.Add(oref);
}
}
writer.WriteArrayRefEntries(entries.ToArray());
writer.EndObject();
if (context.ShouldLogDebug)
{
context.TraceLog.End(TraceLevel.Verbose, "Annotation Collection", "Completed the output of " + entries.Count + " annotations on the writer");
}
return(annot);
}
/// <summary>
/// Renders the widths to the output writer
/// </summary>
/// <param name="context"></param>
/// <param name="writer"></param>
/// <returns></returns>
public PDFObjectRef RenderToPDF(PDFContextBase context, PDFWriter writer)
{
PDFObjectRef oref = writer.BeginObject();
this.RenderWidthsArrayToPDF(context, writer);
writer.EndObject();
return(oref);
}
internal override PDFObjectRef WriteTo(PDFWriter writer)
{
PDFObjectRef oref = writer.BeginObject("StandardEncryption");
writer.BeginDictionary();
writer.WriteDictionaryNameEntry("Filter", "Standard");
this.WriteStandardSecurityEntries(writer);
writer.EndDictionary();
writer.EndObject();
return(oref);
}
/// <summary>
/// Overrides the default method to write a 4 element array
/// </summary>
/// <param name="writer"></param>
protected override void RenderCustomColorSpace(PDFWriter writer)
{
writer.BeginDictionaryEntry("ColorSpace");
if (null == this.Pallette || this.Pallette.Length == 0)
{
throw new NullReferenceException("Palette");
}
else
{
PDFObjectRef index = writer.BeginObject();
writer.BeginArray();
writer.BeginArrayEntry();
writer.WriteName("Indexed");
writer.EndArrayEntry();
writer.BeginArrayEntry();
ColorSpace cs = this.Pallette[0].ColorSpace;
if (cs == ColorSpace.RGB)
{
writer.WriteName("DeviceRGB");
}
else if (cs == ColorSpace.G)
{
writer.WriteName("DeviceG");
}
else
{
throw new ArgumentOutOfRangeException("Palette[0].ColorSpace");
}
writer.EndArrayEntry();
writer.BeginArrayEntry();
writer.WriteNumber(this.Pallette.Length - 1);//maximum value not number of entries
writer.EndArrayEntry();
//check the stored instance
if (null == _bytestreamdata)
{
_bytestreamdata = GetPaletteString(cs);
}
writer.BeginArrayEntry();
writer.WriteByteString(_bytestreamdata);
writer.EndArrayEntry();
writer.EndArray();
writer.EndObject();
writer.WriteObjectRef(index);
}
writer.EndDictionaryEntry();
}
/// <summary>
/// Outputs the document catalog (usually the first Component) and then calls output on each of the documents
/// </summary>
/// <param name="context"></param>
/// <param name="writer"></param>
/// <returns></returns>
protected virtual PDFObjectRef WriteCatalog(PDFRenderContext context, PDFWriter writer)
{
PDFObjectRef catalog = writer.BeginObject("Catalog");
writer.BeginDictionary();
writer.WriteDictionaryNameEntry("Type", "Catalog");
WriteCatalogEntries(context, writer);
writer.EndDictionary();
writer.EndObject();
return(catalog);
}
public PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
{
if (this.Roots.Count > 0)
{
if (context.ShouldLogDebug)
{
context.TraceLog.Begin(TraceLevel.Verbose, "Outline Stack", "Starting to render the outline tree");
}
PDFObjectRef outlines = writer.BeginObject();
writer.BeginDictionary();
writer.WriteDictionaryNameEntry("Type", "Outlines");
PDFObjectRef first, last;
int count;
this.RenderOutlineCollection(this.Roots, outlines, context, writer, out first, out last, out count);
if (null != first)
{
writer.WriteDictionaryObjectRefEntry("First", first);
}
if (null != last)
{
writer.WriteDictionaryObjectRefEntry("Last", last);
}
if (count > 0)
{
writer.WriteDictionaryNumberEntry("Count", count);
}
writer.EndDictionary();
writer.EndObject();//outlines
if (context.ShouldLogDebug)
{
context.TraceLog.End(TraceLevel.Verbose, "Outline Stack", "Finished rendering the outline tree");
}
else if (context.ShouldLogVerbose)
{
context.TraceLog.Add(TraceLevel.Verbose, "Outline Stack", "Rendered the outline tree to indirect object " + outlines + " with first " + first + ", last " + last + " and count " + count);
}
return(outlines);
}
else
{
return(null);
}
}
protected override PDFObjectRef DoRenderToPDF(PDFContextBase context, PDFWriter writer)
{
PDFObjectRef oref = writer.BeginObject();
writer.BeginDictionaryS();
writer.WriteDictionaryNameEntry("Type", "ExtGState");
foreach (PDFName name in this.States.Keys)
{
writer.BeginDictionaryEntry(name);
this.States[name].WriteData(writer);
writer.EndDictionaryEntry();
}
writer.EndDictionary();
writer.EndObject();
return(oref);
}
private PDFObjectRef RenderAlpaImageData(PDFContextBase context, PDFWriter writer)
{
context.TraceLog.Add(TraceLevel.Debug, "IMAGE", "Rendering image alpha mask");
PDFObjectRef mask = writer.BeginObject();
writer.BeginDictionary();
writer.WriteDictionaryNameEntry("Type", "XObject");
writer.WriteDictionaryNameEntry("Subtype", "Image");
writer.WriteDictionaryNumberEntry("Width", this.PixelWidth);
writer.WriteDictionaryNumberEntry("Height", this.PixelHeight);
//writer.WriteDictionaryNumberEntry("Length", this.AlphaData.LongLength);
writer.WriteDictionaryNameEntry("ColorSpace", "DeviceGray");
writer.WriteDictionaryNumberEntry("BitsPerComponent", 8);
this.WriteFilterNames(context, writer);
//writer.EndDictionary();
writer.BeginStream(mask);
byte[] data;
if (this.HasFilter && this.ShouldApplyFilters(context))
{
data = this.GetAlphaFilteredData(this.Filters, context);
if (null == data)
{
data = this.ApplyFiltersToData(this.AlphaData, context);
this.SetAlphaFilteredData(this.Filters, data, context);
}
}
else
{
data = this.AlphaData;
}
writer.WriteRaw(data, 0, data.Length);
writer.EndStream();
//inserted 15/01/15 - Write the filtered length, not the actua image data length to the dictionary.
writer.WriteDictionaryNumberEntry("Length", data.Length);
writer.EndDictionary();
//end of insert
writer.EndObject();
return(mask);
}
internal PDFObjectRef Render(PDFName name, PDFContextBase context, PDFWriter writer)
{
if (context.ShouldLogDebug)
{
context.TraceLog.Begin(TraceLevel.Message, "Image Data", "Rendering image data for '" + name.ToString() + "'");
}
PDFObjectRef renderref = writer.BeginObject(name.Value);
writer.BeginDictionaryS();
writer.WriteDictionaryNameEntry("Name", name.Value);
writer.WriteDictionaryNameEntry("Type", "XObject");
writer.WriteDictionaryNameEntry("Subtype", "Image");
RenderImageInformation(context, writer);
//writer.EndDictionary(); //- commented for data length fix
writer.BeginStream(renderref);
int length = this.RenderImageStreamData(context, writer);
writer.EndStream();
//Added for Data Length fix HRB 15/01/2015
writer.WriteDictionaryNumberEntry("Length", length);
writer.EndDictionary();
//End of add
writer.EndObject();
if (context.ShouldLogDebug)
{
context.TraceLog.End(TraceLevel.Message, "Image Data", "Completed render of the image data for '" + name + "' with source " + this.SourcePath);
}
else
{
context.TraceLog.Add(TraceLevel.Message, "Image Data", "Rendered the image data for '" + name.ToString() + "' with source " + this.SourcePath);
}
return(renderref);
}
protected override PDFObjectRef DoRenderToPDF(PDFContextBase context, PDFWriter writer)
{
PDFObjectRef oref = writer.BeginObject(this.Name.Value);
writer.BeginDictionary();
writer.WriteDictionaryNameEntry("Type", "Pattern");
writer.WriteDictionaryNumberEntry("PatternType", (int)this.PatternType);
//Actual shading dictionary
var shading = this.RenderShadingDictionary(context, writer);
if (null != shading)
{
writer.WriteDictionaryObjectRefEntry("Shading", shading);
}
writer.EndDictionary();
writer.EndObject();
return(oref);
}
public PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
{
if (this.Fields.Count > 0)
{
PDFObjectRef fields = writer.BeginObject();
writer.BeginDictionary();
OutputFields(context, writer);
//OutputDefaultResources(context, writer);
writer.EndDictionary();
writer.EndObject();
return(fields);
}
else
{
return(null);
}
}
/// <summary>
/// Outputs all the names within this dictionary to a new PDFObject in output writer and returns a reference to the dictionary
/// </summary>
/// <param name="context"></param>
/// <param name="writer"></param>
/// <returns></returns>
public PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
{
PDFObjectRef names = writer.BeginObject();
writer.BeginDictionary();
if (_dests.Count > 0)
{
List <string> all = new List <string>(_dests.Keys);
all.Sort();
PDFObjectRef dests = WriteDestinationNames(context, writer, all);
writer.WriteDictionaryObjectRefEntry("Dests", dests);
}
writer.EndDictionary();
writer.EndObject();
return(names);
}
/// <summary>
/// Writes the collection of page labels and returns a reference to this collection
/// </summary>
/// <param name="context"></param>
/// <param name="writer"></param>
/// <returns></returns>
private PDFObjectRef WritePageLabels(PDFRenderContext context, PDFWriter writer)
{
PDFPageNumbers nums = this.Numbers;
PDFObjectRef labels = writer.BeginObject("PageLabels");
writer.BeginDictionary();
writer.BeginDictionaryEntry("Nums");
writer.BeginArrayS();
//PDFPageNumberRegistration def = this.Numbers.;
//this.WriteAPageLabel(context, writer, def);
foreach (PDFPageNumberRegistration entry in this.Numbers.Registrations)
{
WriteAPageLabel(context, writer, entry);
}
writer.EndArray();
writer.EndDictionaryEntry();
writer.EndDictionary();
writer.EndObject();
return(labels);
}
/// <summary>
/// Outputs the entire contents of this name dictionary to the specified writer
/// </summary>
/// <param name="context"></param>
/// <param name="writer"></param>
/// <returns></returns>
public PDFObjectRef OutputToPDF(PDFRenderContext context, PDFWriter writer)
{
PDFObjectRef names = null;
if (this.InnerDictionary.Count > 0)
{
names = writer.BeginObject();
writer.BeginDictionary();
foreach (KeyValuePair <string, PDFCategorisedNameTree> kvp in this.InnerDictionary)
{
PDFObjectRef oref = kvp.Value.OutputToPDF(writer, context);
if (null != oref)
{
writer.WriteDictionaryObjectRefEntry(kvp.Key, oref);
}
}
writer.EndDictionary();
writer.EndObject();
}
return(names);
}
/// <summary>
/// This will render the actual content of the XObject graphical content in a new object reference.
/// This can then be referred to.
/// </summary>
/// <param name="context"></param>
/// <param name="writer"></param>
/// <returns></returns>
private PDFObjectRef OutputContent(PDFRenderContext context, PDFWriter writer)
{
PDFObjectRef xObject = writer.BeginObject();
IStreamFilter[] filters = (context.Compression == OutputCompressionType.FlateDecode) ? this._page.PageCompressionFilters : null;
writer.BeginStream(xObject, filters);
this.Location = context.Offset.Offset(0, this.Line.OffsetY);
PDFSize origSpace = context.Space.Clone();
PDFGraphics prevGraphics = context.Graphics;
using (PDFGraphics g = this.CreateGraphics(writer, context.StyleStack, context))
{
context.Graphics = g;
g.SaveGraphicsState();
g.RestoreGraphicsState();
context.Offset = Drawing.PDFPoint.Empty;
this._childContainer.OutputToPDF(context, writer);
}
context.Offset = this.Location;
context.Space = origSpace;
context.Graphics = prevGraphics;
long len = writer.EndStream();
writer.BeginDictionary();
this.WriteXObjectDictionaryContent(context, writer, len, filters);
writer.EndDictionary();
writer.EndObject();
return(xObject);
}
internal PDFObjectRef Render(PDFName name, PDFContextBase context, PDFWriter writer)
{
if (context.ShouldLogDebug)
{
context.TraceLog.Begin(TraceLevel.Message, "Path Data", "Rendering path data for '" + name.ToString() + "'");
}
PDFObjectRef renderref = writer.BeginObject(name.Value);
writer.BeginDictionaryS();
writer.WriteDictionaryNameEntry("Name", name.Value);
writer.WriteDictionaryNameEntry("Type", "XObject");
writer.WriteDictionaryNameEntry("Subtype", "Image");
RenderPathInformation(context, writer, renderref);
int length = this.RenderPathData(context, writer, renderref);
writer.WriteDictionaryNumberEntry("Length", length);
writer.EndDictionary();
//End of add
writer.EndObject();
if (context.ShouldLogDebug)
{
context.TraceLog.End(TraceLevel.Message, "Path Data", "Completed render of the path data for '" + name.ToString());
}
else
{
context.TraceLog.Add(TraceLevel.Message, "Path Data", "Rendered the path data for '" + name.ToString());
}
return(renderref);
}
public PDFObjectRef WriteResourceList(PDFContextBase context, PDFWriter writer)
{
PDFObjectRef oref = writer.BeginObject();
writer.BeginDictionary();
if (this._includeProcSet)
{
writer.BeginDictionaryEntry("ProcSet");
writer.WriteArrayNameEntries(ProcSets);
writer.EndDictionaryEntry();
}
foreach (PDFResourceItemList list in this.types)
{
writer.BeginDictionaryEntry(list.Type);
writer.BeginDictionary();
foreach (PDFResource rsrc in list)
{
PDFObjectRef rref = rsrc.EnsureRendered(context, writer);
if (rref != null)
{
writer.BeginDictionaryEntry(rsrc.Name);
writer.WriteObjectRef(rref);
writer.EndDictionaryEntry();
}
}
writer.EndDictionary();
writer.EndDictionaryEntry();
}
writer.EndDictionary();
writer.EndObject();
return(oref);
}
/// <summary>
/// Writes all the destinations to the current PDF Object
/// </summary>
/// <param name="context"></param>
/// <param name="writer"></param>
/// <param name="all"></param>
/// <returns></returns>
private PDFObjectRef WriteDestinationNames(PDFRenderContext context, PDFWriter writer, IEnumerable <string> all)
{
PDFObjectRef dests = writer.BeginObject();
writer.BeginDictionary();
//Write the names array
writer.BeginDictionaryEntry("Names");
writer.BeginArray();
string firstname = string.Empty;
string lastname = string.Empty;
foreach (string name in all)
{
if (WriteDestination(context, writer, name))
{
if (string.IsNullOrEmpty(firstname))
{
firstname = name;
}
lastname = name;
}
}
writer.EndArray();
writer.EndDictionaryEntry();
//Write limits
writer.BeginDictionaryEntry("Limits");
writer.WriteArrayStringEntries(firstname, lastname);
writer.EndDictionaryEntry();
writer.EndDictionary();
writer.EndObject();
return(dests);
}
private PDFObjectRef RenderOutlineItem(PDFOutlineRef outlineref, PDFObjectRef parent, PDFObjectRef prev, PDFRenderContext context, PDFWriter writer, out int count)
{
PDFOutline outline = outlineref.Outline;
Scryber.Drawing.PDFColor c = outlineref.GetColor();
Scryber.Drawing.FontStyle fs = outlineref.GetFontStyle();
bool isopen = outlineref.GetIsOpen();
count = 1;//this one
PDFObjectRef item = writer.BeginObject();
writer.BeginDictionary();
writer.WriteDictionaryObjectRefEntry("Parent", parent);
writer.WriteDictionaryStringEntry("Title", outline.Title);
writer.WriteDictionaryStringEntry("Dest", outline.DestinationName);
if (null != c)
{
writer.BeginDictionaryEntry("C");
writer.BeginArray();
writer.WriteRealS(c.Red.Value, c.Green.Value, c.Blue.Value);
writer.EndArray();
writer.EndDictionaryEntry();
}
if (fs != Scryber.Drawing.FontStyle.Regular)
{
int f = 0;
if ((fs & Scryber.Drawing.FontStyle.Bold) > 0)
{
f = 2;
}
if ((fs & Scryber.Drawing.FontStyle.Italic) > 0)
{
f += 1;
}
writer.WriteDictionaryNumberEntry("F", f);
}
if (null != prev)
{
writer.WriteDictionaryObjectRefEntry("Prev", prev);
}
if (context.ShouldLogVerbose)
{
context.TraceLog.Add(TraceLevel.Verbose, "Outline Stack", "Rendered outline item " + item + " with title '" + outline.Title + " and destination name " + outline.DestinationName);
}
if (outlineref.HasInnerItems)
{
if (context.ShouldLogDebug)
{
context.TraceLog.Begin(TraceLevel.Debug, "Outline Stack", "Started rendering inner outline items");
}
int opencount;
PDFObjectRef childfirst, childlast;
this.RenderOutlineCollection(outlineref.InnerItems, item, context, writer, out childfirst, out childlast, out opencount);
writer.WriteDictionaryObjectRefEntry("First", childfirst);
writer.WriteDictionaryObjectRefEntry("Last", childlast);
if (opencount > 0)
{
if (isopen)
{
writer.WriteDictionaryNumberEntry("Count", opencount);
count += opencount;
}
else
{
writer.WriteDictionaryNumberEntry("Count", -opencount);
}
}
if (context.ShouldLogDebug)
{
context.TraceLog.End(TraceLevel.Debug, "Outlines", " Finished rendering inner outline items");
}
}
//we don't close the dictionary here as we need the next entry written
//It should be closed in the calling method
return(item);
}
public PDFObjectRef RenderToPDF(string fullname, PDFContextBase context, PDFWriter writer)
{
if (context.ShouldLogDebug)
{
context.TraceLog.Add(TraceLevel.Debug, "Font Descriptor", "Rendering the font descriptor information");
}
PDFObjectRef oref = writer.BeginObject();
writer.BeginDictionary();
writer.WriteDictionaryNameEntry("Type", "FontDescriptor");
writer.WriteDictionaryNameEntry("FontName", fullname);
if (this.FontFamily != String.Empty)
{
writer.WriteDictionaryStringEntry("FontFamily", this.FontFamily);
}
if (this.BoundingBox != null && this.BoundingBox.Length > 0)
{
writer.BeginDictionaryEntry("FontBBox");
writer.WriteArrayNumberEntries(this.BoundingBox);
writer.EndDictionaryEntry();
}
if (this.FontStretch != FontStretch.Normal)
{
writer.WriteDictionaryStringEntry("FontStretch", this.FontStretch.ToString());
}
if (this.Weight != 400)
{
writer.WriteDictionaryNumberEntry("FontWeight", this.Weight);
}
writer.WriteDictionaryNumberEntry("FontWeight", 700);
writer.WriteDictionaryNumberEntry("Flags", (int)this.Flags);
writer.WriteDictionaryNumberEntry("Ascent", (int)(this.Ascent * 0.6));
writer.WriteDictionaryNumberEntry("Descent", this.Descent);
//if (this.Leading != 0.0)
// writer.WriteDictionaryNumberEntry("Leading", this.Leading);
if (this.CapHeight != 0.0)
{
writer.WriteDictionaryNumberEntry("CapHeight", this.CapHeight);
}
if (this.XHeight != 0.0)
{
writer.WriteDictionaryNumberEntry("XHeight", this.XHeight);
}
writer.WriteDictionaryNumberEntry("StemV", this.StemV);
writer.WriteDictionaryNumberEntry("ItalicAngle", this.ItalicAngle);
if (this.StemH != 0.0)
{
writer.WriteDictionaryNumberEntry("StemH", this.StemH);
}
if (this.AvgWidth != 0.0)
{
writer.WriteDictionaryNumberEntry("AvgWidth", this.AvgWidth);
}
if (this.MaxWidth != 0.0)
{
writer.WriteDictionaryNumberEntry("MaxWidth", this.MaxWidth);
}
if (this.MissingWidth != 0.0)
{
writer.WriteDictionaryNumberEntry("MissingWidth", this.MissingWidth);
}
if (this.FontFile != null)
{
if (context.ShouldLogDebug)
{
context.TraceLog.Add(TraceLevel.Debug, "Font Descriptor", "Rendering the font descriptor font file");
}
byte[] outputdata = this.FontFile;
string filter = null;
if (context.Compression == OutputCompressionType.FlateDecode)
{
if (context.ShouldLogDebug)
{
context.TraceLog.Add(TraceLevel.Debug, "Font Descriptor", "Ensuring the font data is compressed");
}
outputdata = this.FilteredFontFile;
filter = this.FilterName;
}
PDFObjectRef fileref = writer.BeginObject();
writer.BeginDictionary();
writer.WriteDictionaryNumberEntry("Length", outputdata.Length);
if (this.FontType == FontType.TrueType)
{
writer.WriteDictionaryNumberEntry("Length1", this.FontFile.Length);
}
else
{
throw new ArgumentOutOfRangeException("FontType");
}
if (!string.IsNullOrEmpty(filter))
{
writer.WriteDictionaryNameEntry("Filter", this.FilterName);
}
writer.EndDictionary();
writer.BeginStream(fileref);
writer.WriteRaw(outputdata, 0, outputdata.Length);
writer.EndStream();
writer.EndObject();
//We know this is a true type font program from above
writer.WriteDictionaryObjectRefEntry("FontFile2", fileref);
}
writer.EndDictionary();
writer.EndObject();
if (context.ShouldLogDebug)
{
context.TraceLog.Add(TraceLevel.Debug, "Font Descriptor", "Completed font descriptor");
}
return(oref);
}
protected override PDFObjectRef DoOutputToPDF(PDFRenderContext context, PDFWriter writer)
{
List <PDFObjectRef> all = new List <PDFObjectRef>();
if (context.ShouldLogDebug)
{
context.TraceLog.Begin(TraceLevel.Debug, "Link Annotation", "Outputting all required link annotations for component " + this.Component.UniqueID);
}
int pageindex = context.PageIndex;
PDFComponentArrangement arrange = this.Component.GetFirstArrangement();
int index = 1;
while (null != arrange && arrange.PageIndex == pageindex)
{
PDFObjectRef annotref = writer.BeginObject();
writer.BeginDictionary();
writer.WriteDictionaryNameEntry("Type", "Annot");
writer.WriteDictionaryNameEntry("Subtype", "Link");
if (!string.IsNullOrEmpty(this.AlternateText))
{
writer.WriteDictionaryStringEntry("Contents", this.AlternateText);
}
PDFRect bounds = arrange.RenderBounds;
if (bounds != PDFRect.Empty && bounds.Size != PDFSize.Empty)
{
if (context.DrawingOrigin == DrawingOrigin.TopLeft)
{
//PDFs have origin at bottom so need to convert.
PDFReal value = context.Graphics.GetXPosition(bounds.X.RealValue);
bounds.X = new PDFUnit(value.Value, PageUnits.Points);
value = context.Graphics.GetYPosition(bounds.Y.RealValue);
bounds.Y = new PDFUnit(value.Value, PageUnits.Points);
bounds.Width = bounds.X + bounds.Width;
bounds.Height = bounds.Y - bounds.Height;
}
else
{
bounds.Width = bounds.X + bounds.Width;
bounds.Height = bounds.Y + bounds.Height;
}
writer.BeginDictionaryEntry("Rect");
writer.WriteArrayRealEntries(bounds.X.Value, bounds.Y.Value, bounds.Width.Value, bounds.Height.Value);
writer.EndDictionaryEntry();
}
string name = this.Component.UniqueID + "_" + index.ToString();
writer.WriteDictionaryStringEntry("NM", name);
//Draw the border
StyleValue <LineType> lstyle;
/* if (this.AnnotationStyle != null && this.AnnotationStyle.TryGetValue(StyleKeys.BorderStyleKey, out lstyle) && lstyle != null && lstyle.Value != LineType.None)
* {
* PDFUnit corner = this.AnnotationStyle.GetValue(StyleKeys.BorderCornerRadiusKey, (PDFUnit)0);
* PDFUnit width = this.AnnotationStyle.GetValue(StyleKeys.BorderWidthKey, (PDFUnit)1);
* PDFColor c = this.AnnotationStyle.GetValue(StyleKeys.BorderColorKey, PDFColors.Transparent);
*
* if (c != null && width > 0)
* {
* writer.BeginDictionaryEntry("Border");
* writer.WriteArrayRealEntries(corner.PointsValue, corner.PointsValue, width.PointsValue);
* writer.EndDictionaryEntry();
*
* writer.BeginDictionaryEntry("C");
* if (c.ColorSpace == ColorSpace.G)
* writer.WriteArrayRealEntries(c.Gray.Value);
* else if (c.ColorSpace == ColorSpace.RGB)
* writer.WriteArrayRealEntries(c.Red.Value, c.Green.Value, c.Blue.Value);
* else if (context.Conformance == ParserConformanceMode.Strict)
* RecordAndRaise.ArgumentOutOfRange("c", Errors.ColorValueIsNotCurrentlySupported, c.ColorSpace);
* else
* context.TraceLog.Add(TraceLevel.Error, "Link Annotation", string.Format(Errors.ColorValueIsNotCurrentlySupported, c.ColorSpace));
*
* writer.EndDictionaryEntry();
* }
*
* }
* else
* { */
writer.BeginDictionaryEntry("Border");
//writer.WriteArrayRealEntries(1.0, 1.0, 1.0);
writer.WriteArrayRealEntries(0.0, 0.0, 0.0);
writer.EndDictionaryEntry();
//}
if (null != this.Action)
{
writer.BeginDictionaryEntry("A");
PDFObjectRef actionref = this.Action.OutputToPDF(context, writer);
if (null != actionref)
{
writer.WriteObjectRefS(actionref);
}
writer.EndDictionaryEntry();
}
writer.EndDictionary();
writer.EndObject();
if (context.ShouldLogDebug)
{
context.TraceLog.Add(TraceLevel.Debug, "Link Annotation", "Annotation added " + name + " for bounds " + bounds + " on page " + context.PageIndex);
}
all.Add(annotref);
//If we have more than one arrangement on the object then move to the next one
if (arrange is PDFComponentMultiArrangement)
{
arrange = ((PDFComponentMultiArrangement)arrange).NextArrangement;
}
index++;
}
if (all.Count == 0)
{
if (context.ShouldLogDebug)
{
context.TraceLog.End(TraceLevel.Debug, "Link Annotation", "No required link annotations for component " + this.Component.UniqueID);
}
return(null);
}
else if (all.Count == 1)
{
return(all[0]);
}
else
{
if (context.ShouldLogDebug)
{
context.TraceLog.End(TraceLevel.Debug, "Link Annotation", "All " + all.Count + " link annotations for component " + this.Component.UniqueID + " were output");
}
PDFObjectRef array = writer.BeginObject();
writer.WriteArrayRefEntries(all.ToArray());
writer.EndObject();
return(array);
}
}
public Native.PDFObjectRef OutputToPDF(PDFWriter writer, PDFRenderContext context)
{
List <ICategorisedArtefactNamesEntry> entries = new List <ICategorisedArtefactNamesEntry>();
Native.PDFObjectRef oref = null;
if (this.InnerEntries.Count == 0)
{
return(oref);
}
if (this.NameType == PDFCategorisedNameDictionary.DestinationsName)
{
oref = writer.BeginObject();
writer.BeginDictionary();
writer.BeginDictionaryEntry("Names");
string first = null;
string last = null;
writer.BeginArray();
foreach (KeyValuePair <string, IArtefactEntry> kvp in this.InnerEntries)
{
if (string.IsNullOrEmpty(first))
{
first = kvp.Key;
}
else
{
last = kvp.Key;
}
writer.BeginArrayEntry();
writer.WriteStringLiteral(kvp.Key);
writer.EndArrayEntry();
writer.BeginArrayEntry();
((PDFDestination)kvp.Value).OutputToPDF(context, writer);
writer.EndArrayEntry();
writer.WriteLine();
}
writer.EndArray();
writer.EndDictionaryEntry();
if (!string.IsNullOrEmpty(first) && !string.IsNullOrEmpty(last))
{
writer.BeginDictionaryEntry("Limits");
writer.WriteArrayStringEntries(true, first, last);
writer.EndDictionaryEntry();
}
writer.EndDictionary();
writer.EndObject();
}
else //we contain ICategorizedArtefactNameEntry(s)
{
oref = writer.BeginObject();
writer.BeginDictionary();
writer.BeginDictionaryEntry("Names");
//string first = null;
//string last = null;
writer.BeginArray();
foreach (KeyValuePair <string, IArtefactEntry> kvp in this.InnerEntries)
{
//if (string.IsNullOrEmpty(first))
// first = kvp.Key;
//else
// last = kvp.Key;
writer.BeginArrayEntry();
writer.WriteStringLiteral(kvp.Key);
writer.EndArrayEntry();
writer.BeginArrayEntry();
ICategorisedArtefactNamesEntry entry = (ICategorisedArtefactNamesEntry)kvp.Value;
Native.PDFObjectRef entryOref = entry.OutputToPDF(context, writer);
if (null != entryOref)
{
writer.WriteObjectRef(entryOref);
}
writer.EndArrayEntry();
writer.WriteLine();
}
writer.EndArray();
writer.EndDictionaryEntry();
//Limits only required on Intermediate and Leaf nodes of a tree, not the root
//if (!string.IsNullOrEmpty(first) && !string.IsNullOrEmpty(last))
//{
// writer.BeginDictionaryEntry("Limits");
// writer.WriteArrayStringEntries(true, first, last);
// writer.EndDictionaryEntry();
//}
writer.EndDictionary();
writer.EndObject();
}
return(oref);
}
//
// methods
//
#region protected override PDFObjectRef DoRenderToPDF(PDFContextBase context, PDFWriter writer)
/// <summary>
/// Renders the tiling image
/// </summary>
/// <param name="context"></param>
/// <param name="writer"></param>
/// <returns></returns>
protected override PDFObjectRef DoRenderToPDF(PDFContextBase context, PDFWriter writer)
{
IStreamFilter[] filters = writer.DefaultStreamFilters;
PDFObjectRef pattern = writer.BeginObject();
writer.BeginDictionary();
writer.WriteDictionaryNameEntry("Type", "Pattern");
writer.WriteDictionaryNumberEntry("PatternType", (int)this.PatternType);
writer.WriteDictionaryNumberEntry("PaintType", (int)this.PaintType);
writer.WriteDictionaryNumberEntry("TilingType", (int)this.TilingType);
writer.BeginDictionaryEntry("BBox");
PDFPoint offset = new PDFPoint(this.Start.X, this.Start.Y - this.ImageSize.Height);// this.Start;
PDFSize size = this.ImageSize;
PDFSize graphicsSize = new PDFSize(size.Width + offset.X, size.Height + offset.Y);
writer.WriteArrayRealEntries(true, offset.X.PointsValue,
offset.Y.PointsValue,
offset.X.PointsValue + size.Width.PointsValue,
offset.Y.PointsValue + size.Height.PointsValue);
writer.EndDictionaryEntry();
writer.WriteDictionaryRealEntry("XStep", this.Step.Width.PointsValue);
writer.WriteDictionaryRealEntry("YStep", this.Step.Height.PointsValue);
PDFObjectRef all = this.Resources.WriteResourceList(context, writer);
writer.WriteDictionaryObjectRefEntry("Resources", all);
writer.BeginStream(pattern);
using (PDFGraphics g = PDFGraphics.Create(writer, false, this, DrawingOrigin.TopLeft,
graphicsSize, context))
{
offset = new PDFPoint(offset.X, 0.0);
g.PaintImageRef(this.Image, size, offset);
}
long len = writer.EndStream();
if (null != filters && filters.Length > 0)
{
writer.BeginDictionaryEntry("Length");
writer.WriteNumberS(len);
writer.EndDictionaryEntry();
writer.BeginDictionaryEntry("Filter");
writer.BeginArray();
foreach (IStreamFilter filter in filters)
{
writer.BeginArrayEntry();
writer.WriteName(filter.FilterName);
writer.EndArrayEntry();
}
writer.EndArray();
writer.EndDictionaryEntry();
}
else
{
writer.BeginDictionaryEntry("Length");
writer.WriteNumberS(len);
writer.EndDictionaryEntry();
}
writer.EndDictionary();
writer.EndObject();
return(pattern);
}
protected virtual PDFObjectRef OutputContent(PDFRenderContext context, PDFWriter writer)
{
PDFObjectRef oref = writer.BeginObject();
IStreamFilter[] filters = (context.Compression == OutputCompressionType.FlateDecode) ? this.PageCompressionFilters : null;
writer.BeginStream(oref, filters);
PDFPoint pt = context.Offset.Clone();
PDFSize sz = context.Space.Clone();
using (PDFGraphics g = this.CreateGraphics(writer, context.StyleStack, context))
{
context.Graphics = g;
if (null != this.HeaderBlock)
{
this.HeaderBlock.OutputToPDF(context, writer);
}
this.ContentBlock.OutputToPDF(context, writer);
if (null != this.FooterBlock)
{
this.FooterBlock.OutputToPDF(context, writer);
}
if (_outputbadge)
{
this.PaintBadgeXObj(context, writer);
}
}
context.Offset = pt;
context.Space = sz;
long len = writer.EndStream();
writer.BeginDictionary();
if (null != filters && filters.Length > 0)
{
writer.BeginDictionaryEntry("Length");
writer.WriteNumberS(len);
writer.EndDictionaryEntry();
writer.BeginDictionaryEntry("Filter");
writer.BeginArray();
foreach (IStreamFilter filter in filters)
{
writer.BeginArrayEntry();
writer.WriteName(filter.FilterName);
writer.EndArrayEntry();
}
writer.EndArray();
writer.EndDictionaryEntry();
}
else
{
writer.BeginDictionaryEntry("Length");
writer.WriteNumberS(len);
writer.EndDictionaryEntry();
}
writer.EndDictionary();
writer.EndObject();
return(oref);
}
protected override PDFObjectRef DoOutputToPDF(PDFRenderContext context, PDFWriter writer)
{
//Get the default font and size required for the DA (default Appearance value)
var xObject = this._states[FormFieldAppearanceState.Normal];
if (null == xObject)
{
return(null);
}
PDFObjectRef root = writer.BeginObject();
var font = this._style.CreateFont();
var rsrc = xObject.Document.GetResource(Scryber.Resources.PDFResource.FontDefnResourceType, font.FullName, true);
string da = rsrc.Name.ToString() + " " + font.Size.ToPoints().Value.ToString() + " Tf";
writer.BeginDictionary();
writer.WriteDictionaryNameEntry("Subtype", "Widget");
writer.WriteDictionaryStringEntry("T", this.Name);
if (!string.IsNullOrEmpty(this.Value))
{
writer.WriteDictionaryStringEntry("V", this.Value);
}
if (!string.IsNullOrEmpty(this.DefaultValue))
{
writer.WriteDictionaryStringEntry("DV", this.DefaultValue);
}
writer.WriteDictionaryNumberEntry("Ff", (int)this.FieldOptions + (int)this.FieldType);
writer.WriteDictionaryStringEntry("DA", da);
writer.WriteDictionaryNameEntry("FT", GetFieldTypeName(this.FieldType));
if (null != this._page && null != this._page.PageObjectRef)
{
writer.WriteDictionaryObjectRefEntry("P", this._page.PageObjectRef);
}
//MK - appearance dictionary
writer.BeginDictionaryEntry("MK");
writer.BeginDictionary();
if (this._style.IsValueDefined(Styles.StyleKeys.BorderColorKey))
{
WriteInputColor(context, writer, "BC", this._style.Border.Color);
}
if (this._style.IsValueDefined(Styles.StyleKeys.BgColorKey))
{
WriteInputColor(context, writer, "BG", this._style.Background.Color);
}
writer.EndDictionary();
writer.EndDictionaryEntry();
if (this._states.Count > 0)
{
_location = context.Offset;
Drawing.PDFRect bounds = Drawing.PDFRect.Empty;
writer.BeginDictionaryEntry("AP");
writer.BeginDictionary();
foreach (var kvp in _states)
{
xObject = kvp.Value;
FormFieldAppearanceState state = kvp.Key;
PDFObjectRef oref = xObject.OutputToPDF(context, writer);
if (null != oref)
{
PDFSize sz = new Drawing.PDFSize(xObject.Width, xObject.Height);
if (_size == PDFSize.Empty)
{
_size = sz;
}
else
{
if (_size.Width < sz.Width)
{
_size.Width = sz.Width;
}
if (_size.Height < sz.Height)
{
_size.Height = sz.Height;
}
}
var name = GetFieldStateName(kvp.Key);
writer.WriteDictionaryObjectRefEntry(name, oref);
//We should have all states starting at the same location no matter what.
this._location = xObject.Location;
}
}
writer.EndDictionary();
writer.EndDictionaryEntry();
PDFReal left = context.Graphics.GetXPosition(_location.X);
PDFReal top = context.Graphics.GetYPosition(_location.Y);
PDFReal right = left + context.Graphics.GetXOffset(_size.Width);
PDFReal bottom = top + context.Graphics.GetYOffset(_size.Height);
writer.BeginDictionaryEntry("Rect");
writer.WriteArrayRealEntries(true, left.Value, bottom.Value, right.Value, top.Value);
writer.EndDictionaryEntry();
}
writer.EndDictionary();
writer.EndObject();
//context.Offset = new PDFPoint(context.Offset.X, context.Offset.Y + _size.Height);
return(root);
}
