AcquireResourceStreamForXpsColorContext(
string resourceId
)
{
XpsResourceStream resourceStream = null;
if (_currentXpsColorContextRef == 0)
{
try
{
XpsPrintStream colorContextStreamWrapper = XpsPrintStream.CreateXpsPrintStream();
Uri colorContextUri = _xpsManager.GenerateUniqueUri(XpsS0Markup.ColorContextContentType);
_colorContextResourceStream = new XpsResourceStream(colorContextStreamWrapper, colorContextUri);
IStream _colorIStream = colorContextStreamWrapper.GetManagedIStream();
IOpcPartUri partUri = GenerateIOpcPartUri(colorContextUri);
IXpsOMColorProfileResource colorResource = _xpsOMFactory.CreateColorProfileResource(_colorIStream, partUri);
IXpsOMColorProfileResourceCollection colorCollection = _xpsPartResources.GetColorProfileResources();
colorCollection.Append(colorResource);
}
catch (COMException)
{
Invalidate();
throw new PrintingCanceledException();
}
}
_currentXpsColorContextRef++;
resourceStream = _colorContextResourceStream;
return(resourceStream);
}
AcquireResourceStreamForXpsFont(
string resourceId
)
{
XpsResourceStream resourceStream = null;
ResourceStreamCacheItem resourceStreamCacheItem = (ResourceStreamCacheItem)_fontsCache[resourceId];
if (resourceStreamCacheItem == null)
{
resourceStreamCacheItem = new ResourceStreamCacheItem();
//
// We need to create the corresponding part in the Xps package
// and then acquire the Stream
//
if (_currentFixedPageXmlWriter != null)
{
try
{
Uri uri = GenerateUriForObfuscatedFont();
IOpcPartUri partUri = GenerateIOpcPartUri(uri);
XpsPrintStream fontStreamWrapper = XpsPrintStream.CreateXpsPrintStream();
IStream fontIStream = fontStreamWrapper.GetManagedIStream();
IXpsOMFontResource fontResource = _xpsOMFactory.CreateFontResource(fontIStream, XPS_FONT_EMBEDDING.XPS_FONT_EMBEDDING_OBFUSCATED, partUri, 1);
IXpsOMFontResourceCollection fontCollection = _xpsPartResources.GetFontResources();
fontCollection.Append(fontResource);
XpsResourceStream fontResourceStream = new XpsResourceStream(fontStreamWrapper, uri);
resourceStreamCacheItem.XpsResourceStream = fontResourceStream;
_fontsCache[resourceId] = resourceStreamCacheItem;
resourceStream = fontResourceStream;
}
catch (COMException)
{
Invalidate();
throw new PrintingCanceledException();
}
}
else
{
throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NoFixedPageWriter));
}
}
else
{
resourceStream = resourceStreamCacheItem.XpsResourceStream;
resourceStreamCacheItem.IncRef();
}
return(resourceStream);
}
AcquireResourceStreamForXpsImage(
string resourceId
)
{
XpsResourceStream resourceStream = null;
if (resourceId == null)
{
throw new ArgumentNullException(nameof(resourceId));
}
ContentType contentType = new ContentType(resourceId);
if (ContentType.Empty.AreTypeAndSubTypeEqual(contentType))
{
throw new ArgumentException(SR.Get(SRID.ReachPackaging_InvalidContentType, contentType.ToString()));
}
if (_currentXpsImageRef == 0)
{
try
{
_currentImageType = GetXpsImageTypeFromContentType(contentType);
XpsPrintStream imageStreamWrapper = XpsPrintStream.CreateXpsPrintStream();
Uri imageUri = _xpsManager.GenerateUniqueUri(contentType);
_imageResourceStream = new XpsResourceStream(imageStreamWrapper, imageUri);
IStream imageIStream = imageStreamWrapper.GetManagedIStream();
IOpcPartUri partUri = GenerateIOpcPartUri(imageUri);
IXpsOMImageResource imageResource = _xpsOMFactory.CreateImageResource(imageIStream, _currentImageType, partUri);
IXpsOMImageResourceCollection imageCollection = _xpsPartResources.GetImageResources();
imageCollection.Append(imageResource);
}
catch (COMException)
{
Invalidate();
throw new PrintingCanceledException();
}
}
_currentXpsImageRef++;
resourceStream = _imageResourceStream;
return(resourceStream);
}
AcquireResourceStreamForXpsResourceDictionary(String resourceId)
{
XpsResourceStream resourceStream = null;
if (_currentXpsResourceDictionaryRef == 0)
{
//
// We need to create the corresponding part in the Xps package
// and then acquire the Stream
//
if (_currentFixedPageHelper != null)
{
String fileName = FileHelper.GenerateFileName(XpsFileType.ResourceDictionary, _path);
Stream dictionaryStream = FileHelper.CreateFile(fileName, _path);
//Add image to the fixed page relationships
String dictionaryUri = "/" + fileName;
_fixedPageRelationshipStream.AddFixedRelationship(_requiredResource, dictionaryUri);
_resourceDictionaryResourceStream = new XpsResourceStream(dictionaryStream, new Uri(dictionaryUri, UriKind.Relative));
//Add content type to file
_contentTypeFile.AddType(XpsFileType.ResourceDictionary,
FileHelper.GetExtension(XpsFileType.ResourceDictionary));
}
else
{
throw new ArgumentNullException("Fixed Page Writer was not allocated before XpsResourceDictionary was serialized");
}
}
_currentXpsResourceDictionaryRef++;
resourceStream = _resourceDictionaryResourceStream;
return(resourceStream);
}
/// <Summary>
/// Acquires a ResourceStream for an XpsImage.</Summary>
/// <param name="resourceId">
/// The MIME type of the image - image/png, image/jpeg,
/// image/tiff, image/vnd.ms-photo.</param>
public override XpsResourceStream AcquireResourceStreamForXpsImage(String resourceId)
{
XpsResourceStream resourceStream = null;
if (_currentXpsImageRef == 0)
{
//
// We need to create the corresponding part in
// the Xps package and then acquire the Stream
//
if (_currentFixedPageHelper != null)
{
// Create a new image Stream
XpsFileType imageType;
switch (resourceId)
{
case "image/png":
imageType = XpsFileType.ImagePng;
break;
case "image/jpeg":
imageType = XpsFileType.ImageJpg;
break;
case "image/tiff":
imageType = XpsFileType.ImageTif;
break;
case "image/vnd.ms-photo":
imageType = XpsFileType.ImageWmp;
break;
default:
throw new ArgumentException("Invalid image type");
}
String fileName = FileHelper.GenerateFileName(imageType, _path);
Stream imageStream = FileHelper.CreateFile(fileName, _path);
//Add image to the fixed page relationships
String imageUri = "/" + fileName;
_fixedPageRelationshipStream.AddFixedRelationship(_requiredResource, imageUri);
_imageResourceStream = new XpsResourceStream(imageStream, new Uri(imageUri, UriKind.Relative));
//Add content type to file
_contentTypeFile.AddType(imageType,
FileHelper.GetExtension(imageType));
}
else
{
throw new ArgumentNullException("Fixed Page Writer was not allocated before XpsImage was serialized");
}
}
_currentXpsImageRef++;
resourceStream = _imageResourceStream;
return(resourceStream);
}
// ------------------- AcquireResourceStreamForXpsFont -------------------
/// <Summary>
/// Acquires a ResourceStream for an XpsFont with a specified ID.</Summary>
/// <param name="resourceId">
/// The ID of the Resource.</param>
public override XpsResourceStream AcquireResourceStreamForXpsFont(String resourceId)
{
XpsResourceStream resourceStream = null;
ResourceStreamCacheItem resourceStreamCacheItem =
(ResourceStreamCacheItem)_fontsCache[resourceId];
if (resourceStreamCacheItem == null)
{
resourceStreamCacheItem = new ResourceStreamCacheItem();
//
// We need to create the corresponding part in the Xps package
// and then acquire the Stream
//
Stream fontStream = null;
String fileName;
if (_currentFixedPageHelper != null)
{
// Create a new Font Stream
fileName = FileHelper.GenerateFileName(XpsFileType.Font, _path);
fontStream = FileHelper.CreateFile(fileName, _path);
if (fontStream != null)
{
resourceStreamCacheItem.XpsResource = null;
//
// retreive the appropriate stream and uri from the package API layer
//
String fileUri = "/" + fileName;
_fontResourceStream = new XpsResourceStream(
fontStream, new Uri(fileUri, UriKind.Relative));
resourceStreamCacheItem.XpsResourceStream = _fontResourceStream;
_fontsCache[resourceId] = resourceStreamCacheItem;
resourceStream = _fontResourceStream;
//Add Obfuscatedfont type to content type file
_contentTypeFile.AddType(XpsFileType.ObfuscatedFont,
FileHelper.GetExtension(XpsFileType.ObfuscatedFont));
fontStream = null;
}
else
{
throw new ArgumentNullException("Could not create FontStream");
}
}
else
{
throw new XpsSerializationException("No FixedPage Writer");
}
}
else
{
resourceStream = resourceStreamCacheItem.XpsResourceStream;
resourceStreamCacheItem.IncRef();
}
//Add relationship to fixedpage for resource stream
_fixedPageRelationshipStream.AddFixedRelationship(
_requiredResource, resourceStream.Uri.ToString());
return(resourceStream);
}
