private static void InitWPFResourcesSystem()
{
// Hinky stuff to get the resource dictionary working
PackUriHelper.Create(new Uri("reliable://0"));
new FrameworkElement();
Application.ResourceAssembly = typeof(App).Assembly;
}
private static Uri GetStructureUriFromRelationship(Uri contentUri, string relationshipName)
{
Uri result = null;
if (contentUri != null && relationshipName != null)
{
Uri partUri = PackUriHelper.GetPartUri(contentUri);
if (partUri != null)
{
Uri packageUri = PackUriHelper.GetPackageUri(contentUri);
Package package = PreloadedPackages.GetPackage(packageUri);
if (package == null && SecurityHelper.CheckEnvironmentPermission())
{
package = PackageStore.GetPackage(packageUri);
}
if (package != null)
{
PackagePart part = package.GetPart(partUri);
PackageRelationshipCollection relationshipsByType = part.GetRelationshipsByType(relationshipName);
Uri uri = null;
foreach (PackageRelationship packageRelationship in relationshipsByType)
{
uri = PackUriHelper.ResolvePartUri(partUri, packageRelationship.TargetUri);
}
if (uri != null)
{
result = PackUriHelper.Create(packageUri, uri);
}
}
}
}
return(result);
}
/// <summary>
/// Loads xaml content from a WPF package.
/// </summary>
/// <param name="stream">
/// Stream that must be accessible for reading and structured as
/// a WPF container: part XamlEntryPart is expected as one of
/// its entry parts.
/// </param>
/// <returns>
/// Returns a xaml element loaded from the entry part of the package.
/// </returns>
/// <exception cref="ArgumentNullException">
/// Throws parsing exception when the xaml content does not comply with the xaml schema.
/// </exception>
/// <exception cref="ArgumentException">
/// Throws validation exception when the package is not well structured.
/// </exception>
/// <exception cref="Exception">
/// Throws uri exception when the pachageBaseUri is not correct absolute uri.
/// </exception>
/// <remarks>
/// USED IN LEXICON VIA REFLECTION
/// </remarks>
internal static object LoadElement(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
object xamlObject;
try
{
WpfPayload wpfPayload = WpfPayload.OpenWpfPayload(stream);
// Now load the package
using (wpfPayload.Package)
{
// Validate WPF paypoad and get its entry part
PackagePart xamlEntryPart = wpfPayload.ValidatePayload();
// Define a unique uri for this instance of PWF payload.
// Uniqueness is required to make sure that cached images are not mixed up.
int newWpfPayoutCount = Interlocked.Increment(ref _wpfPayloadCount);
Uri payloadUri = new Uri("payload://wpf" + newWpfPayoutCount, UriKind.Absolute);
Uri entryPartUri = PackUriHelper.Create(payloadUri, xamlEntryPart.Uri); // gives an absolute uri of the entry part
Uri packageUri = PackUriHelper.GetPackageUri(entryPartUri); // extracts package uri from combined package+part uri
PackageStore.AddPackage(packageUri, wpfPayload.Package); // Register the package
// Set this temporary uri as a base uri for xaml parser
ParserContext parserContext = new ParserContext();
parserContext.BaseUri = entryPartUri;
// Call xaml parser
xamlObject = XamlReader.Load(xamlEntryPart.GetStream(), parserContext);
// Remove the temporary uri from the PackageStore
PackageStore.RemovePackage(packageUri);
}
}
catch (XamlParseException e)
{
// Incase of xaml parsing or package structure failure
// we return null.
Invariant.Assert(e != null); //to make compiler happy about not using a variable e. This variable is useful in debugging process though - to see a reason of a parsing failure
xamlObject = null;
}
catch (System.IO.FileFormatException)
{
xamlObject = null;
}
catch (System.IO.FileLoadException)
{
xamlObject = null;
}
catch (System.OutOfMemoryException)
{
xamlObject = null;
}
return(xamlObject);
}
static int _wpfPayloadCount; // used to disambiguate between all acts of loading from different WPF payloads.
internal static object LoadElement(Stream stream)
{
Package package = Package.Open(stream, FileMode.Open, FileAccess.Read);
WpfPayload wpfPayload = new WpfPayload(package);
PackagePart xamlEntryPart = wpfPayload.GetWpfEntryPart();
int newWpfPayoutCount = _wpfPayloadCount++;
Uri payloadUri = new Uri("payload://wpf" + newWpfPayoutCount, UriKind.Absolute);
Uri entryPartUri = PackUriHelper.Create(payloadUri, xamlEntryPart.Uri); // gives an absolute uri of the entry part
Uri packageUri = PackUriHelper.GetPackageUri(entryPartUri); // extracts package uri from combined package+part uri
PackageStore.AddPackage(packageUri, wpfPayload.Package); // Register the package
ParserContext parserContext = new ParserContext();
parserContext.BaseUri = entryPartUri;
object xamlObject = XamlReader.Load(xamlEntryPart.GetStream(), parserContext);
// Remove the temporary uri from the PackageStore
PackageStore.RemovePackage(packageUri);
return(xamlObject);
}
public void Setup()
{
a = PackUriHelper.Create(new Uri("http://www.test.com/pack1.pkg"));
b = PackUriHelper.Create(new Uri("http://www.test.com/pack2.pkg"));
Console.WriteLine("A is: {0}", a);
Console.WriteLine("B is: {0}", b);
}
public void RoundTripTest(Stream originalStream, XamlWriterMode expressionMode, bool attemptDisplay)
{
if (originalStream == null)
{
throw new ArgumentNullException("originalStream");
}
Dispatcher dispatcher = Dispatcher.CurrentDispatcher;
if (dispatcher == null)
{
throw new InvalidOperationException("The current thread has not entered a Dispatcher.");
}
object firstTreeRoot = null;
//
// Parse original xaml.
// We create a ParserContext here. It will be reused by subsequent parsing
// operations.
//
GlobalLog.LogStatus("Constructing object tree using LoadXml...");
_parserContext = new ParserContext();
_parserContext.BaseUri = PackUriHelper.Create(new Uri("siteoforigin://"));
firstTreeRoot = ParseXaml(originalStream);
RoundTripTestObject(firstTreeRoot, expressionMode, attemptDisplay);
}
}// end:GetPackage()
// ------------------------ GetFixedDocument --------------------------
/// <summary>
/// Returns the fixed document at a given URI within
/// the currently open XPS package.</summary>
/// <param name="fixedDocUri">
/// The URI of the fixed document to return.</param>
/// <returns>
/// The fixed document at a given URI
/// within the current XPS package.</returns>
private FixedDocument GetFixedDocument(Uri fixedDocUri)
{
FixedDocument fixedDocument = null;
// Create the URI for the fixed document within the package. The URI
// is used to set the Parser context so fonts & other items can load.
Uri tempUri = new Uri(_xpsDocumentPath, UriKind.RelativeOrAbsolute);
ParserContext parserContext = new ParserContext();
parserContext.BaseUri = PackUriHelper.Create(tempUri);
// Retrieve the fixed document.
PackagePart fixedDocPart = _xpsPackage.GetPart(fixedDocUri);
if (fixedDocPart != null)
{
object fixedObject =
XamlReader.Load(fixedDocPart.GetStream(), parserContext);
if (fixedObject != null)
{
fixedDocument = fixedObject as FixedDocument;
}
}
return(fixedDocument);
}// end:GetFixedDocument()
static BaseUriHelper()
{
_siteOfOriginBaseUri = PackUriHelper.Create(new Uri("SiteOfOrigin://"));
_packAppBaseUri = PackUriHelper.Create(new Uri("application://"));
BaseUriProperty = DependencyProperty.RegisterAttached("BaseUri", typeof(Uri), typeof(BaseUriHelper), new PropertyMetadata((object)null));
_baseUri = new MS.Internal.SecurityCriticalDataForSet <Uri>(_packAppBaseUri);
PreloadedPackages.AddPackage(PackUriHelper.GetPackageUri(SiteOfOriginBaseUri), new SiteOfOriginContainer(), true);
}
/// <summary>Creates a Pack URI for a content file.</summary>
/// <param name="assemblyName">
/// The assembly name where the content resides.
/// </param>
/// <param name="path">The relative pack URI of the file.</param>
/// <returns>An absolute content file Pack URI.</returns>
public static Uri MakeContentPackUri(AssemblyName assemblyName, string path)
{
var name = FormatName(assemblyName);
return(PackUriHelper.Create(
ContentFileAuthority,
new Uri($"/{name};component/{path}", UriKind.Relative)));
}
public void Setup()
{
PackUriHelper.Create(new Uri("someuri://0"));
new FrameworkElement();
System.Windows.Application.ResourceAssembly = typeof(App).Assembly;
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
}
public Tests()
{
PackUriHelper.Create(new Uri("http://example.com"));
var asm = Assembly.GetExecutingAssembly();
assetPath = Path.GetDirectoryName(asm.Location);
baseUri = new Uri($"pack://application:,,,/{asm.GetName().Name};Component/");
}
public static Uri ToPackUri(this string relativePath)
{
if (!relativePath.StartsWith("/"))
{
relativePath = "/" + relativePath;
}
return(PackUriHelper.Create(new Uri("application:///"),
new Uri(relativePath, UriKind.Relative)));
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
#region NON-PUBLIC PROCEDURES
/////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Gets an absolute pack URI for the assembly resource identified by <paramref name="relativeUri"/>.
/// </summary>
/// <param name="relativeUri">The relative path to the resource.</param>
/// <returns></returns>
private static Uri GetResourceUri(Uri relativeUri)
{
if (relativeUri.IsAbsoluteUri)
{
throw new ArgumentException("value must be a relative URI", "relativeUri");
}
return(PackUriHelper.Create(
new Uri("application:///", UriKind.Absolute),
new Uri("/" + Assembly.GetExecutingAssembly().GetName().Name + ";component" + relativeUri, UriKind.Relative)));
}
public void GetPartUriTest()
{
var pack = PackUriHelper.Create(new Uri("http://www.test.com/pack1.pkg"));
var part = new Uri("/main.html", UriKind.Relative);
var pack_part = new Uri(@"pack://pack:,,http:%2C%2Cwww.test.com%2Cpack1.pkg,/main.html");
Assert.IsNull(PackUriHelper.GetPartUri(pack), "#1");
Assert.AreEqual(pack_part, PackUriHelper.Create(pack, part), "#2");
Assert.AreEqual(part, PackUriHelper.GetPartUri(PackUriHelper.Create(pack, part)), "#3");
}
public Uri CreatePart(Stream stream, string contentType)
{
var partUri = new Uri("/stream" + (++this.partCounter) + ".ttf", UriKind.Relative);
var part = this.package.CreatePart(partUri, contentType);
using (var partStream = part.GetStream())
CopyStream(stream, partStream);
// Each packUri must be globally unique because WPF might perform some caching based on it.
return(PackUriHelper.Create(this.packageUri, partUri));
}
/// <summary>
/// Using PackWebRequest to retrieve the photo from photo package on
/// archive server.
/// </summary>
/// <param name="packageUri">
/// Absolute Uri of the photo package on archive server.
/// </param>
/// <param name="partUri">
/// Part Uri of the photo in the photo package.
/// </param>
/// <returns>
/// WebResponse that has the stream of requested photo image.
/// </returns>
private static WebResponse PackWebRequestForPhotoPart(Uri packageUri,
Uri partUri)
{
Uri fullUri = PackUriHelper.Create(packageUri, partUri);
Console.WriteLine("Pack URI= " + fullUri);
// Create PackWebRequest.
WebRequest request = _webRequestCreate.Create(fullUri);
return(request.GetResponse());
}
public void CreateTest()
{
Assert.AreEqual("pack://http:,,www.test.com,pack.pkg/",
PackUriHelper.Create(new Uri("http://www.test.com/pack.pkg")).ToString(), "#1");
Assert.AreEqual("pack://http:,,www.test.com,pack.pkg/",
PackUriHelper.Create(new Uri("http://www.test.com/pack.pkg"), null, null).ToString(), "#2");
Assert.AreEqual("pack://http:,,www.test.com,pack.pkg/main.html#frag",
PackUriHelper.Create(new Uri("http://www.test.com/pack.pkg"),
new Uri("/main.html", UriKind.Relative), "#frag").ToString(), "#3");
Assert.AreEqual("pack://http:,,www.test.com,pack.pkg/main.html#frag",
PackUriHelper.Create(new Uri("http://www.test.com/pack.pkg"),
new Uri("/main.html", UriKind.Relative), "#frag").ToString(), "#3");
}
public Uri CreatePart(Stream stream, string contentType = "application/octet-stream")
{
var partUri = new Uri("/stream" + ++partCounter, UriKind.Relative);
var part = package.CreatePart(partUri, contentType);
Debug.Assert(part != null, "part != null");
using (var partStream = part.GetStream())
CopyStream(stream, partStream);
// Each packUri must be globally unique because WPF might perform some caching based on it.
return(PackUriHelper.Create(this.packageUri, partUri));
}
/// <summary>
/// Pack Uri's are not recognized untill they have been registered in the appl domain
/// This method makes sure pack Uri's do no throw an exception regarding incorrect port.
/// </summary>
private void SetupRecognizePackUir()
{
PackUriHelper.Create(new Uri("reliable://0"));
new FrameworkElement();
try
{
Application.ResourceAssembly = typeof(AddinRibbonPart).Assembly;
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public void TestConvert()
{
PackUriHelper.Create(new Uri("reliable://0"));
//new FrameworkElement();
var converter = new LogLevelImageConverter();
var im = converter.Convert("Info", null, null, null);
Assert.IsNotNull(im);
im = converter.Convert("Warn", null, null, null);
Assert.IsNotNull(im);
im = converter.Convert("Error", null, null, null);
Assert.IsNotNull(im);
}
// Token: 0x06003F20 RID: 16160 RVA: 0x0012075C File Offset: 0x0011E95C
internal static object LoadElement(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
object result;
try
{
WpfPayload wpfPayload = WpfPayload.OpenWpfPayload(stream);
using (wpfPayload.Package)
{
PackagePart packagePart = wpfPayload.ValidatePayload();
int num = Interlocked.Increment(ref WpfPayload._wpfPayloadCount);
Uri packageUri = new Uri("payload://wpf" + num, UriKind.Absolute);
Uri uri = PackUriHelper.Create(packageUri, packagePart.Uri);
Uri packageUri2 = PackUriHelper.GetPackageUri(uri);
PackageStore.AddPackage(packageUri2, wpfPayload.Package);
ParserContext parserContext = new ParserContext();
parserContext.BaseUri = uri;
bool useRestrictiveXamlReader = !Clipboard.UseLegacyDangerousClipboardDeserializationMode();
result = XamlReader.Load(packagePart.GetStream(), parserContext, useRestrictiveXamlReader);
PackageStore.RemovePackage(packageUri2);
}
}
catch (XamlParseException ex)
{
Invariant.Assert(ex != null);
result = null;
}
catch (FileFormatException)
{
result = null;
}
catch (FileLoadException)
{
result = null;
}
catch (OutOfMemoryException)
{
result = null;
}
return(result);
}
private void RegisterFonts()
{
foreach (KeyValuePair <string, byte[]> fontFile in ChapterContent.Fonts)
{
MemoryStream packageStream = new MemoryStream();
Package package = Package.Open(packageStream, FileMode.Create, FileAccess.ReadWrite);
Uri packageUri = new Uri(fontFile.Key + ":");
PackageStore.AddPackage(packageUri, package);
Uri packPartUri = new Uri("/content", UriKind.Relative);
PackagePart packPart = package.CreatePart(packPartUri, "font/content");
packPart.GetStream().Write(fontFile.Value, 0, fontFile.Value.Length);
Uri fontUri = PackUriHelper.Create(packageUri, packPart.Uri);
foreach (FontFamily fontFamilty in System.Windows.Media.Fonts.GetFontFamilies(fontUri))
{
HtmlRender.AddFontFamily(fontFamilty);
}
}
areFontsRegistered = true;
}
private void CheckUri(string localName, string attr)
{
if (!object.ReferenceEquals(attr, _lastAttr)) // Check for same string object, not for equality!
{
_lastAttr = attr;
string [] uris = _schema.ExtractUriFromAttr(localName, attr);
if (uris != null)
{
foreach (string uriAttr in uris)
{
if (uriAttr.Length > 0)
{
Uri targetUri = PackUriHelper.ResolvePartUri(_baseUri, new Uri(uriAttr, UriKind.Relative));
Uri absTargetUri = PackUriHelper.Create(_packageUri, targetUri);
_loader.UriHitHandler(_node, absTargetUri);
}
}
}
}
}
// Token: 0x06008483 RID: 33923 RVA: 0x00248558 File Offset: 0x00246758
private void CheckUri(string localName, string attr)
{
if (attr != this._lastAttr)
{
this._lastAttr = attr;
string[] array = this._schema.ExtractUriFromAttr(localName, attr);
if (array != null)
{
foreach (string text in array)
{
if (text.Length > 0)
{
Uri partUri = PackUriHelper.ResolvePartUri(this._baseUri, new Uri(text, UriKind.Relative));
Uri uri = PackUriHelper.Create(this._packageUri, partUri);
this._loader.UriHitHandler(this._node, uri);
}
}
}
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
IList list = SpellCheck.GetCustomDictionaries(textBox);
string fileName = "customwords.lex";
System.IO.StreamReader file = new System.IO.StreamReader(fileName);
string line;
StringBuilder sb = new StringBuilder();
while ((line = file.ReadLine()) != null)
{
System.Console.WriteLine(line);
sb.Append(line);
sb.Append("\r\n");
}
// Create in-memory Package to store custom dictionary
UTF8Encoding encoding = new UTF8Encoding();
var bytes = encoding.GetBytes(sb.ToString());
MemoryStream stream = new MemoryStream();
Package pack = Package.Open(stream, FileMode.Create, FileAccess.ReadWrite);
Uri packUri = new Uri("SpellCheckDictionary:");
PackageStore.RemovePackage(packUri);
PackageStore.AddPackage(packUri, pack);
Uri packPartUri = new Uri("/Content", UriKind.Relative);
PackagePart packPart = pack.CreatePart(packPartUri, "text/plain");
if (packPart != null)
{
Stream packageStream = packPart.GetStream();
packageStream.Write(bytes, 0, bytes.Length);
packageStream.Close();
spellUri = PackUriHelper.Create(packUri, packPart.Uri);
}
textBox.SpellCheck.CustomDictionaries.Clear();
textBox.SpellCheck.CustomDictionaries.Add(spellUri);
}
public void Setup()
{
MockDeploymentRepositoryAdapter = new Mock <IDeploymentRepositoryAdapter>();
MockConnectionTester = new Mock <IConnectionTester>();
MockConnectionTester.Setup(m => m.Test()).ReturnsAsync((true, String.Empty));
MockContainer = new MockContainer
{
MockDeploymentRepositoryAdapter = MockDeploymentRepositoryAdapter,
MockConnectionTester = MockConnectionTester,
};
// Set the server URL so the settings command isn't run
Properties.Settings.Default.ServerUrl = "http://localhost";
Container.Current = MockContainer;
Container.Current.Configure();
PackUriHelper.Create(new Uri("reliable://0"));
new FrameworkElement();
Application.ResourceAssembly = typeof(App).Assembly;
}
internal void Cleanup()
{
if (Application.Current != null)
{
IBrowserCallbackServices browserCallbackServices = Application.Current.BrowserCallbackServices;
if (browserCallbackServices != null)
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new DispatcherOperationCallback(this.ReleaseBrowserCallback), browserCallbackServices);
}
}
this.ServiceProvider = null;
this.ClearRootBrowserWindow();
if (this._storageRoot != null && this._storageRoot.Value != null)
{
this._storageRoot.Value.Close();
}
if (this._document.Value is PackageDocument)
{
PreloadedPackages.RemovePackage(PackUriHelper.GetPackageUri(PackUriHelper.Create(this.Uri)));
((PackageDocument)this._document.Value).Dispose();
this._document.Value = null;
}
if (this._mimeType.Value == MimeType.Document)
{
DocumentManager.CleanUp();
}
if (this._packageStream.Value != null)
{
this._packageStream.Value.Close();
}
if (this._unmanagedStream.Value != null)
{
Marshal.ReleaseComObject(this._unmanagedStream.Value);
this._unmanagedStream = new SecurityCriticalData <object>(null);
}
}
public bool OpenEncryptedDocument(string xpsFile)
{
// Check to see if the document is encrypted.
// If not encrypted, use OpenDocument().
if (!EncryptedPackageEnvelope.IsEncryptedPackageEnvelope(xpsFile))
return OpenDocument(xpsFile);
ShowStatus("Opening encrypted '" + Filename(xpsFile) + "'");
// Get the ID of the current user log-in.
string currentUserId;
try
{ currentUserId = GetDefaultWindowsUserName(); }
catch
{ currentUserId = null; }
if (currentUserId == null)
{
MessageBox.Show("No valid user ID available", "Invalid User ID",
MessageBoxButton.OK, MessageBoxImage.Error);
ShowStatus(" No valid user ID available.");
return false;
}
ShowStatus(" Current user ID: '" + currentUserId + "'");
ShowStatus(" Using " + _authentication + " authentication.");
ShowStatus(" Checking rights list for user:\n " +
currentUserId);
ShowStatus(" Initializing the environment.");
try
{
string applicationManifest = "<manifest></manifest>";
if (File.Exists("rvc.xml"))
{
ShowStatus(" Reading manifest 'rvc.xml'.");
StreamReader manifestReader = File.OpenText("rvc.xml");
applicationManifest = manifestReader.ReadToEnd();
}
ShowStatus(" Initiating SecureEnvironment as user: \n " +
currentUserId + " [" + _authentication + "]");
if (SecureEnvironment.IsUserActivated(
new ContentUser(currentUserId, _authentication)))
{
ShowStatus(" User is already activated.");
_secureEnv = SecureEnvironment.Create(applicationManifest,
new ContentUser(currentUserId, _authentication));
}
else // if user is not yet activated.
{
ShowStatus(" User is NOT activated,\n activating now....");
// If using the current Windows user, no credentials are
// required and we can use UserActivationMode.Permanent.
_secureEnv = SecureEnvironment.Create(applicationManifest,
_authentication, UserActivationMode.Permanent);
// If not using the current Windows user, use
// UserActivationMode.Temporary to display the Windows
// credentials pop-up window.
///_secureEnv = SecureEnvironment.Create(applicationManifest,
/// a_authentication, UserActivationMode.Temporary);
}
ShowStatus(" Created SecureEnvironment for user:\n " +
_secureEnv.User.Name +
" [" + _secureEnv.User.AuthenticationType + "]");
ShowStatus(" Opening the encrypted Package.");
EncryptedPackageEnvelope ePackage =
EncryptedPackageEnvelope.Open(xpsFile, FileAccess.ReadWrite);
RightsManagementInformation rmi =
ePackage.RightsManagementInformation;
ShowStatus(" Looking for an embedded UseLicense for user:\n " +
currentUserId + " [" + _authentication + "]");
UseLicense useLicense =
rmi.LoadUseLicense(
new ContentUser(currentUserId, _authentication));
ReadOnlyCollection<ContentGrant> grants;
if (useLicense == null)
{
ShowStatus(" No Embedded UseLicense found.\n " +
"Attempting to acqure UseLicnese\n " +
"from the PublishLicense.");
PublishLicense pubLicense = rmi.LoadPublishLicense();
ShowStatus(" Referral information:");
if (pubLicense.ReferralInfoName == null)
ShowStatus(" Name: (null)");
else
ShowStatus(" Name: " + pubLicense.ReferralInfoName);
if (pubLicense.ReferralInfoUri == null)
ShowStatus(" Uri: (null)");
else
ShowStatus(" Uri: " +
pubLicense.ReferralInfoUri.ToString());
useLicense = pubLicense.AcquireUseLicense(_secureEnv);
if (useLicense == null)
{
ShowStatus(" User DOES NOT HAVE RIGHTS\n " +
"to access this document!");
return false;
}
}// end:if (useLicense == null)
ShowStatus(" UseLicense acquired.");
ShowStatus(" Binding UseLicense with the SecureEnvironment" +
"\n to obtain the CryptoProvider.");
rmi.CryptoProvider = useLicense.Bind(_secureEnv);
ShowStatus(" Obtaining BoundGrants.");
grants = rmi.CryptoProvider.BoundGrants;
// You can access the Package via GetPackage() at this point.
rightsBlock.Text = "GRANTS LIST\n-----------\n";
foreach (ContentGrant grant in grants)
{
rightsBlock.Text += "USER :"******" [" +
grant.User.AuthenticationType + "]\n";
rightsBlock.Text += "RIGHT :" + grant.Right.ToString()+"\n";
rightsBlock.Text += " From: " + grant.ValidFrom + "\n";
rightsBlock.Text += " Until: " + grant.ValidUntil + "\n";
}
if (rmi.CryptoProvider.CanDecrypt == true)
ShowStatus(" Decryption granted.");
else
ShowStatus(" CANNOT DECRYPT!");
ShowStatus(" Getting the Package from\n" +
" the EncryptedPackage.");
_xpsPackage = ePackage.GetPackage();
if (_xpsPackage == null)
{
MessageBox.Show("Unable to get Package.");
return false;
}
// Set a PackageStore Uri reference for the encrypted stream.
// ("sdk://packLocation" is a pseudo URI used by
// PackUriHelper.Create to define the parserContext.BaseURI
// that XamlReader uses to access the encrypted data stream.)
Uri packageUri = new Uri(@"sdk://packLocation", UriKind.Absolute);
// Add the URI package
PackageStore.AddPackage(packageUri, _xpsPackage);
// Determine the starting part for the package.
PackagePart startingPart = GetPackageStartingPart(_xpsPackage);
// Set the DocViewer.Document property.
ShowStatus(" Opening in DocumentViewer.");
ParserContext parserContext = new ParserContext();
parserContext.BaseUri = PackUriHelper.Create(
packageUri, startingPart.Uri);
parserContext.XamlTypeMapper = XamlTypeMapper.DefaultMapper;
DocViewer.Document = XamlReader.Load(
startingPart.GetStream(), parserContext)
as IDocumentPaginatorSource;
// Enable document menu controls.
menuFileClose.IsEnabled = true;
menuFilePrint.IsEnabled = true;
menuViewIncreaseZoom.IsEnabled = true;
menuViewDecreaseZoom.IsEnabled = true;
// Give the DocumentViewer focus.
DocViewer.Focus();
}// end:try
catch (Exception ex)
{
MessageBox.Show("Exception: " + ex.Message + "\n\n" +
ex.GetType().ToString() + "\n\n" + ex.StackTrace,
"Exception",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
this.Title = "RightsManagedPackageViewer SDK Sample - " +
Filename(xpsFile) + " (encrypted)";
return true;
}// end:OpenEncryptedDocument()
public override void ValidateRelationships(SecurityCriticalData <Package> package, Uri packageUri, Uri partUri, ContentType mimeType)
{
PackagePart part = package.Value.GetPart(partUri);
PackageRelationshipCollection checkRels;
int count;
// Can only have 0 or 1 PrintTicket per FDS, FD or FP part
checkRels = part.GetRelationshipsByType(_printTicketRel);
count = 0;
foreach (PackageRelationship rel in checkRels)
{
count++;
if (count > 1)
{
throw new FileFormatException(SR.Get(SRID.XpsValidatingLoaderMoreThanOnePrintTicketPart));
}
// Also check for existence and type
Uri targetUri = PackUriHelper.ResolvePartUri(partUri, rel.TargetUri);
Uri absTargetUri = PackUriHelper.Create(packageUri, targetUri);
PackagePart targetPart = package.Value.GetPart(targetUri);
if (!_printTicketContentType.AreTypeAndSubTypeEqual(new ContentType(targetPart.ContentType)))
{
throw new FileFormatException(SR.Get(SRID.XpsValidatingLoaderPrintTicketHasIncorrectType));
}
}
checkRels = part.GetRelationshipsByType(_thumbnailRel);
count = 0;
foreach (PackageRelationship rel in checkRels)
{
count++;
if (count > 1)
{
throw new FileFormatException(SR.Get(SRID.XpsValidatingLoaderMoreThanOneThumbnailPart));
}
// Also check for existence and type
Uri targetUri = PackUriHelper.ResolvePartUri(partUri, rel.TargetUri);
Uri absTargetUri = PackUriHelper.Create(packageUri, targetUri);
PackagePart targetPart = package.Value.GetPart(targetUri);
if (!_jpgContentType.AreTypeAndSubTypeEqual(new ContentType(targetPart.ContentType)) &&
!_pngContentType.AreTypeAndSubTypeEqual(new ContentType(targetPart.ContentType)))
{
throw new FileFormatException(SR.Get(SRID.XpsValidatingLoaderThumbnailHasIncorrectType));
}
}
// FixedDocument only has restricted font relationships
if (_fixedDocumentContentType.AreTypeAndSubTypeEqual(mimeType))
{
// Check if target of restricted font relationship is present and is actually a font
checkRels = part.GetRelationshipsByType(_restrictedFontRel);
foreach (PackageRelationship rel in checkRels)
{
// Check for existence and type
Uri targetUri = PackUriHelper.ResolvePartUri(partUri, rel.TargetUri);
Uri absTargetUri = PackUriHelper.Create(packageUri, targetUri);
PackagePart targetPart = package.Value.GetPart(targetUri);
if (!_fontContentType.AreTypeAndSubTypeEqual(new ContentType(targetPart.ContentType)) &&
!_obfuscatedContentType.AreTypeAndSubTypeEqual(new ContentType(targetPart.ContentType)))
{
throw new FileFormatException(SR.Get(SRID.XpsValidatingLoaderRestrictedFontHasIncorrectType));
}
}
}
// check constraints for XPS fixed payload start part
if (_fixedDocumentSequenceContentType.AreTypeAndSubTypeEqual(mimeType))
{
// This is the XPS payload root part. We also should check if the Package only has at most one discardcontrol...
checkRels = package.Value.GetRelationshipsByType(_discardControlRel);
count = 0;
foreach (PackageRelationship rel in checkRels)
{
count++;
if (count > 1)
{
throw new FileFormatException(SR.Get(SRID.XpsValidatingLoaderMoreThanOneDiscardControlInPackage));
}
// Also check for existence and type
Uri targetUri = PackUriHelper.ResolvePartUri(partUri, rel.TargetUri);
Uri absTargetUri = PackUriHelper.Create(packageUri, targetUri);
PackagePart targetPart = package.Value.GetPart(targetUri);
if (!_discardControlContentType.AreTypeAndSubTypeEqual(new ContentType(targetPart.ContentType)))
{
throw new FileFormatException(SR.Get(SRID.XpsValidatingLoaderDiscardControlHasIncorrectType));
}
}
// This is the XPS payload root part. We also should check if the Package only has at most one thumbnail...
checkRels = package.Value.GetRelationshipsByType(_thumbnailRel);
count = 0;
foreach (PackageRelationship rel in checkRels)
{
count++;
if (count > 1)
{
throw new FileFormatException(SR.Get(SRID.XpsValidatingLoaderMoreThanOneThumbnailInPackage));
}
// Also check for existence and type
Uri targetUri = PackUriHelper.ResolvePartUri(partUri, rel.TargetUri);
Uri absTargetUri = PackUriHelper.Create(packageUri, targetUri);
PackagePart targetPart = package.Value.GetPart(targetUri);
if (!_jpgContentType.AreTypeAndSubTypeEqual(new ContentType(targetPart.ContentType)) &&
!_pngContentType.AreTypeAndSubTypeEqual(new ContentType(targetPart.ContentType)))
{
throw new FileFormatException(SR.Get(SRID.XpsValidatingLoaderThumbnailHasIncorrectType));
}
}
}
}
public void Init()
{
PackUriHelper.Create(new Uri("reliable://0"));
Application.LoadComponent(
new Uri("/KBS2;component/App.xaml", UriKind.Relative));
}