AddDocumentStructure(
)
{
if (this.DocumentStructure != null)
{
// Document structure already available for this FixedDocument
throw new XpsPackagingException(SR.Get(SRID.ReachPackaging_MoreThanOneDocStructure));
}
Uri pageUri = this.CurrentXpsManager.CreateStructureUri();
//
// Create the part and writer
//
PackagePart metroPart = this.CurrentXpsManager.GeneratePart(
XpsS0Markup.DocumentStructureContentType,
pageUri);
_documentStructure = new XpsStructure(CurrentXpsManager, this, metroPart);
//
// Create the relationship between the document and the document-structure
// Not in INode.Flush because IXpsFixedDocumentReader has no commit.
//
string structurePath = XpsManager.MakeRelativePath(this.Uri, _documentStructure.Uri);
_metroPart.CreateRelationship(new Uri(structurePath, UriKind.Relative),
TargetMode.Internal,
XpsS0Markup.StructureRelationshipName
);
return(_documentStructure);
}
AddRelationship(
Uri targetUri,
string relationshipName
)
{
//
// We can not read from the file to do validation
// when streaming
//
if (!CurrentXpsManager.Streaming)
{
foreach (PackageRelationship rel in _metroPart.GetRelationships())
{
if (rel.TargetUri.Equals(targetUri))
{
//
// Relationship already exists
//
return;
}
}
}
//
// Add the relationship using a relative path to this page.
//
string relativePath = XpsManager.MakeRelativePath(this.Uri, targetUri);
_metroPart.CreateRelationship(new Uri(relativePath, UriKind.Relative),
TargetMode.Internal,
relationshipName);
}
AddPageToDocument(
Uri partUri,
IList <String> linkTargetStream
)
{
_partEditor.PrepareXmlWriter(XpsS0Markup.FixedDocument, XpsS0Markup.FixedDocumentNamespace);
XmlTextWriter xmlWriter = _partEditor.XmlWriter;
//
// Write <PageContent Target="partUri"/>
//
String relativePath = XpsManager.MakeRelativePath(Uri, partUri);
xmlWriter.WriteStartElement(XpsS0Markup.PageContent);
xmlWriter.WriteAttributeString(XmlTags.Source, relativePath);
//
// Write out link targets if necessary
//
if (linkTargetStream.Count != 0)
{
xmlWriter.WriteRaw("<PageContent.LinkTargets>");
foreach (String nameElement in linkTargetStream)
{
xmlWriter.WriteRaw(String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"<LinkTarget Name=\"{0}\" />",
nameElement)
);
}
xmlWriter.WriteRaw("</PageContent.LinkTargets>");
}
xmlWriter.WriteEndElement();
}
XpsOMPackagingPolicy(
IXpsDocumentPackageTarget packageTarget
)
{
if (packageTarget == null)
{
throw new ArgumentNullException(nameof(packageTarget));
}
try
{
_xpsManager = new XpsManager();
_packageTarget = packageTarget;
_xpsOMFactory = _packageTarget.GetXpsOMFactory();
_xpsPartResources = _xpsOMFactory.CreatePartResources();
}
catch (COMException)
{
Invalidate();
throw new PrintingCanceledException();
}
_fontsCache = new Hashtable(INITIAL_FONTCACHE_CAPACITY);
_isValid = true;
Initialize();
}
XpsFixedDocumentReaderWriter(
XpsManager xpsManager,
INode parent,
PackagePart part,
int documentNumber
)
: base(xpsManager)
{
if (null == part)
{
throw new ArgumentNullException("part");
}
this.Uri = part.Uri;
_metroPart = part;
_partEditor = new XmlPartEditor(_metroPart);
_pageCache = new List <IXpsFixedPageReader>();
_pagesWritten = 0;
_parentNode = parent;
_hasParsedPages = false;
_documentNumber = documentNumber;
}
XpsColorContext(
XpsManager xpsManager,
INode parent,
PackagePart part
)
: base(xpsManager, parent, part)
{
}
XpsImage(
XpsManager xpsManager,
INode parent,
PackagePart part
)
: base(xpsManager, parent, part)
{
}
XpsResourceDictionary(
XpsManager xpsManager,
INode parent,
PackagePart part
)
: base(xpsManager, parent, part)
{
}
XpsThumbnail(
XpsManager xpsManager,
INode parent,
PackagePart part
)
: base(xpsManager, parent, part)
{
}
XpsStructure(
XpsManager xpsManager,
INode parent,
PackagePart part
)
: base(xpsManager, parent, part)
{
}
XpsFont(
XpsManager xpsManager,
INode parent,
PackagePart part
)
: base(xpsManager, parent, part)
{
_isObfuscated = (part.ContentType == XpsS0Markup.FontObfuscatedContentType.ToString());
}
RelativeUri(
Uri inUri
)
{
if (inUri == null)
{
throw new ArgumentNullException("inUri");
}
return(new Uri(XpsManager.MakeRelativePath(this.Uri, inUri), UriKind.Relative));
}
IsSupportedMimeType(
BitmapSource bitmapSource
)
{
BitmapCodecInfo codecInfo = null;
string imageMimeType = "";
if (bitmapSource is BitmapFrame)
{
//
// This code gets the encoder based on the decoder that was
// used for this specific BitmapSource.
//
BitmapFrame bitmapFrame = bitmapSource as BitmapFrame;
if (bitmapFrame != null && bitmapFrame.Decoder != null)
{
codecInfo = bitmapFrame.Decoder.CodecInfo;
}
}
if (codecInfo != null)
{
imageMimeType = codecInfo.MimeTypes;
}
int start = 0;
int comma = imageMimeType.IndexOf(',', start);
bool foundType = false;
//
// Test all strings before commas
//
if (comma != -1)
{
while (comma != -1 && !foundType)
{
string subString = imageMimeType.Substring(start, comma);
foundType = XpsManager.SupportedImageType(new ContentType(subString));
start = comma + 1;
comma = imageMimeType.IndexOf(',', start);
}
}
//
// If we still have not found a supported type
// Test the remainder of the string
//
if (!foundType)
{
foundType = XpsManager.SupportedImageType(new ContentType(imageMimeType.Substring(start)));
}
return(foundType);
}
XpsPartBase(
XpsManager xpsManager
)
{
if (null == xpsManager)
{
throw new ArgumentNullException("xpsManager");
}
_xpsManager = xpsManager;
}
AddDocumentToSequence(
Uri partUri
)
{
_partEditor.PrepareXmlWriter(XpsS0Markup.FixedDocumentSequence, XpsS0Markup.DocumentSequenceNamespace);
XmlTextWriter xmlWriter = _partEditor.XmlWriter;
//
// Write <Item Target="partUri"/>
//
String relativePath = XpsManager.MakeRelativePath(Uri, partUri);
xmlWriter.WriteStartElement(XpsS0Markup.DocumentReference);
xmlWriter.WriteAttributeString(XmlTags.Source, relativePath);
xmlWriter.WriteEndElement();
}
XpsResource(
XpsManager xpsManager,
INode parent,
PackagePart part
)
: base(xpsManager)
{
if (null == part)
{
throw new ArgumentNullException("part");
}
this.Uri = part.Uri;
_parentNode = parent;
_metroPart = part;
_partEditor = new PartEditor(_metroPart);
}
internal virtual void CommitInternal()
{
if (this._xpsManager != null)
{
this._xpsManager = null;
}
}
// Methods
internal XpsPartBase(XpsManager xpsManager)
{
if (xpsManager == null)
{
throw new ArgumentNullException("xpsManager");
}
this._xpsManager = xpsManager;
}
