internal static bool HasPermission(PrintingPermission permission) {
try {
permission.Demand();
return true;
}
catch (SecurityException) {
return false;
}
}
public override bool IsSubsetOf(IPermission target)
{
PrintingPermission pp = Cast(target);
if (pp == null)
{
return(IsEmpty());
}
return(_Level <= pp.Level);
}
public override IPermission Intersect(IPermission target)
{
PrintingPermission pp = Cast(target);
if ((pp == null) || IsEmpty() || pp.IsEmpty())
{
return(null);
}
PrintingPermissionLevel level = (_Level <= pp.Level) ? _Level : pp.Level;
return(new PrintingPermission(level));
}
public override bool IsSubsetOf(IPermission target)
{
if (target == null)
{
return(this.printingLevel == PrintingPermissionLevel.NoPrinting);
}
PrintingPermission permission = target as PrintingPermission;
if (permission == null)
{
throw new ArgumentException(System.Drawing.SR.GetString("TargetNotPrintingPermission"));
}
return(this.printingLevel <= permission.printingLevel);
}
//------------------------------------------------------
//
// IPERMISSION IMPLEMENTATION
//
//------------------------------------------------------
/// <include file='doc\PrintingPermission.uex' path='docs/doc[@for="PrintingPermission.IsSubsetOf"]/*' />
/// <devdoc>
/// <para>Determines whether the current permission object is a subset of
/// the specified permission.</para>
/// </devdoc>
public override bool IsSubsetOf(IPermission target)
{
if (target == null)
{
return(printingLevel == PrintingPermissionLevel.NoPrinting);
}
PrintingPermission operand = target as PrintingPermission;
if (operand == null)
{
throw new ArgumentException(SR.Format(SR.TargetNotPrintingPermission));
}
return(this.printingLevel <= operand.printingLevel);
}
//------------------------------------------------------
//
// IPERMISSION IMPLEMENTATION
//
//------------------------------------------------------
/// <include file='doc\PrintingPermission.uex' path='docs/doc[@for="PrintingPermission.IsSubsetOf"]/*' />
/// <devdoc>
/// <para>Determines whether the current permission object is a subset of
/// the specified permission.</para>
/// </devdoc>
public override bool IsSubsetOf(IPermission target)
{
if (target == null)
{
return(printingLevel == PrintingPermissionLevel.NoPrinting);
}
try {
PrintingPermission operand = (PrintingPermission)target;
return(this.printingLevel <= operand.printingLevel);
}
catch (InvalidCastException) {
throw new ArgumentException(SR.GetString(SR.TargetNotPrintingPermission));
}
}
private PrintingPermission Cast(IPermission target)
{
if (target == null)
{
return(null);
}
PrintingPermission pp = (target as PrintingPermission);
if (pp == null)
{
ThrowInvalidPermission(target, typeof(PrintingPermission));
}
return(pp);
}
public void PermissionState_None ()
{
PermissionState ps = PermissionState.None;
PrintingPermission pp = new PrintingPermission (ps);
Assert.AreEqual (PrintingPermissionLevel.NoPrinting, pp.Level, "Level");
Assert.IsFalse (pp.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = pp.ToXml ();
// only class and version are present
Assert.AreEqual ("NoPrinting", se.Attribute ("Level"), "Xml-Level");
Assert.IsNull (se.Children, "Xml-Children");
PrintingPermission copy = (PrintingPermission)pp.Copy ();
Assert.IsFalse (Object.ReferenceEquals (pp, copy), "ReferenceEquals");
Assert.AreEqual (pp.Level, copy.Level, "Level");
Assert.AreEqual (pp.IsUnrestricted (), copy.IsUnrestricted (), "IsUnrestricted ()");
}
public override IPermission Intersect(IPermission target)
{
if (target == null)
{
return(null);
}
PrintingPermission permission = target as PrintingPermission;
if (permission == null)
{
throw new ArgumentException(System.Drawing.SR.GetString("TargetNotPrintingPermission"));
}
PrintingPermissionLevel printingLevel = (this.printingLevel < permission.printingLevel) ? this.printingLevel : permission.printingLevel;
if (printingLevel == PrintingPermissionLevel.NoPrinting)
{
return(null);
}
return(new PrintingPermission(printingLevel));
}
public override IPermission Union(IPermission target)
{
PrintingPermission pp = Cast(target);
if (pp == null)
{
return(new PrintingPermission(_Level));
}
if (IsUnrestricted() || pp.IsUnrestricted())
{
return(new PrintingPermission(PermissionState.Unrestricted));
}
if (IsEmpty() && pp.IsEmpty())
{
return(null);
}
PrintingPermissionLevel level = (_Level > pp.Level) ? _Level : pp.Level;
return(new PrintingPermission(level));
}
/// <include file='doc\PrintingPermission.uex' path='docs/doc[@for="PrintingPermission.Union"]/*' />
/// <devdoc>
/// <para>Creates a permission that is the union of the permission object
/// and the target parameter permission object.</para>
/// </devdoc>
public override IPermission Union(IPermission target)
{
if (target == null)
{
return(this.Copy());
}
try {
PrintingPermission operand = (PrintingPermission)target;
PrintingPermissionLevel isectLevels = printingLevel > operand.printingLevel ? printingLevel : operand.printingLevel;
if (isectLevels == PrintingPermissionLevel.NoPrinting)
{
return(null);
}
else
{
return(new PrintingPermission(isectLevels));
}
}
catch (InvalidCastException) {
throw new ArgumentException(SR.GetString(SR.TargetNotPrintingPermission));
}
}
/// <include file='doc\PrintingPermission.uex' path='docs/doc[@for="PrintingPermission.Intersect"]/*' />
/// <devdoc>
/// <para>Creates and returns a permission that is the intersection of the current
/// permission object and a target permission object.</para>
/// </devdoc>
public override IPermission Intersect(IPermission target)
{
if (target == null)
{
return(null);
}
PrintingPermission operand = target as PrintingPermission;
if (operand == null)
{
throw new ArgumentException(SR.GetString(SR.TargetNotPrintingPermission));
}
PrintingPermissionLevel isectLevels = printingLevel < operand.printingLevel ? printingLevel : operand.printingLevel;
if (isectLevels == PrintingPermissionLevel.NoPrinting)
{
return(null);
}
else
{
return(new PrintingPermission(isectLevels));
}
}
/// <include file='doc\PrintingPermission.uex' path='docs/doc[@for="PrintingPermission.Union"]/*' />
/// <devdoc>
/// <para>Creates a permission that is the union of the permission object
/// and the target parameter permission object.</para>
/// </devdoc>
public override IPermission Union(IPermission target)
{
if (target == null)
{
return(this.Copy());
}
PrintingPermission operand = target as PrintingPermission;
if (operand == null)
{
throw new ArgumentException(SR.Format(SR.TargetNotPrintingPermission));
}
PrintingPermissionLevel isectLevels = printingLevel > operand.printingLevel ? printingLevel : operand.printingLevel;
if (isectLevels == PrintingPermissionLevel.NoPrinting)
{
return(null);
}
else
{
return(new PrintingPermission(isectLevels));
}
}
public void Intersect_Null ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
// No intersection with null
foreach (PrintingPermissionLevel ppl in AllLevel) {
pp.Level = ppl;
Assert.IsNull (pp.Intersect (null), ppl.ToString ());
}
}
public void Copy ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
foreach (PrintingPermissionLevel ppl in AllLevel) {
pp.Level = ppl;
PrintingPermission copy = (PrintingPermission)pp.Copy ();
Assert.AreEqual (ppl, copy.Level, ppl.ToString ());
}
}
public void FromXml_WrongVersion ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
SecurityElement se = pp.ToXml ();
se.Attributes.Remove ("version");
se.Attributes.Add ("version", "2");
pp.FromXml (se);
}
public void FromXml_NoVersion ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
SecurityElement se = pp.ToXml ();
SecurityElement w = new SecurityElement (se.Tag);
w.AddAttribute ("class", se.Attribute ("class"));
pp.FromXml (w);
}
public void IsSubset_Self ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
foreach (PrintingPermissionLevel ppl in AllLevel) {
pp.Level = ppl;
PrintingPermission result = (PrintingPermission)pp.Intersect (pp);
Assert.IsTrue (pp.IsSubsetOf (pp), ppl.ToString ());
}
}
public void FromXml_NoClass ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
SecurityElement se = pp.ToXml ();
SecurityElement w = new SecurityElement (se.Tag);
w.AddAttribute ("version", se.Attribute ("version"));
pp.FromXml (w);
// note: normally IPermission classes (in corlib) DO NOT care about
// attribute "class" name presence in the XML
}
public void FromXml_Null ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
pp.FromXml (null);
}
public void PermissionState_Bad ()
{
PermissionState ps = (PermissionState)77;
PrintingPermission pp = new PrintingPermission (ps);
}
public void Intersect_None ()
{
PrintingPermission sp1 = new PrintingPermission (PermissionState.None);
PrintingPermission sp2 = new PrintingPermission (PermissionState.None);
foreach (PrintingPermissionLevel ppl in AllLevelExceptNoLevel) {
sp2.Level = ppl;
// 1. Intersect None with ppl
PrintingPermission result = (PrintingPermission)sp1.Intersect (sp2);
Assert.IsNull (result, "None N " + ppl.ToString ());
// 2. Intersect ppl with None
result = (PrintingPermission)sp2.Intersect (sp1);
Assert.IsNull (result, "None N " + ppl.ToString ());
}
}
public void Union_Unrestricted ()
{
// Union with unrestricted is unrestricted
PrintingPermission sp1 = new PrintingPermission (PermissionState.Unrestricted);
PrintingPermission sp2 = new PrintingPermission (PermissionState.None);
// a. source (this) is unrestricted
foreach (PrintingPermissionLevel ppl in AllLevel) {
sp2.Level = ppl;
PrintingPermission union = (PrintingPermission)sp1.Union (sp2);
Assert.IsTrue (union.IsUnrestricted (), "target " + ppl.ToString ());
}
// b. destination (target) is unrestricted
foreach (PrintingPermissionLevel ppl in AllLevel) {
sp2.Level = ppl;
PrintingPermission union = (PrintingPermission)sp2.Union (sp1);
Assert.IsTrue (union.IsUnrestricted (), "source " + ppl.ToString ());
}
}
public void Intersect_Self ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
foreach (PrintingPermissionLevel ppl in AllLevelExceptNoLevel) {
pp.Level = ppl;
PrintingPermission result = (PrintingPermission)pp.Intersect (pp);
Assert.AreEqual (ppl, result.Level, ppl.ToString ());
}
}
public void Intersect_Unrestricted ()
{
// Intersection with unrestricted == Copy
// a. source (this) is unrestricted
PrintingPermission sp1 = new PrintingPermission (PermissionState.Unrestricted);
PrintingPermission sp2 = new PrintingPermission (PermissionState.None);
foreach (PrintingPermissionLevel ppl in AllLevelExceptNoLevel) {
sp2.Level = ppl;
PrintingPermission result = (PrintingPermission)sp1.Intersect (sp2);
Assert.AreEqual (sp2.Level, result.Level, "target " + ppl.ToString ());
}
// b. destination (target) is unrestricted
foreach (PrintingPermissionLevel ppl in AllLevelExceptNoLevel) {
sp2.Level = ppl;
PrintingPermission result = (PrintingPermission)sp2.Intersect (sp1);
Assert.AreEqual (sp2.Level, result.Level, "source " + ppl.ToString ());
}
// exceptions for NoLevel
sp2.Level = PrintingPermissionLevel.NoPrinting;
Assert.IsNull (sp1.Intersect (sp2), "target NoLevel");
Assert.IsNull (sp2.Intersect (sp1), "source NoLevel");
}
public void IsSubset_Unrestricted ()
{
// IsSubset with unrestricted
// a. source (this) is unrestricted -> target is never a subset
PrintingPermission sp1 = new PrintingPermission (PermissionState.Unrestricted);
PrintingPermission sp2 = new PrintingPermission (PermissionState.None);
foreach (PrintingPermissionLevel ppl in AllLevelExceptAllLevel) {
sp2.Level = ppl;
Assert.IsFalse (sp1.IsSubsetOf (sp2), "target " + ppl.ToString ());
}
// exception of AllLevel
sp2.Level = PrintingPermissionLevel.AllPrinting;
Assert.IsTrue (sp1.IsSubsetOf (sp2), "target AllLevel");
// b. destination (target) is unrestricted -> target is always a subset
foreach (PrintingPermissionLevel ppl in AllLevel) {
sp2.Level = ppl;
Assert.IsTrue (sp2.IsSubsetOf (sp1), "source " + ppl.ToString ());
}
}
public void Level_PrintingPermissionLevels_Bad ()
{
PrintingPermissionLevel ppl = (PrintingPermissionLevel)(PrintingPermissionLevel.AllPrinting + 1);
PrintingPermission pp = new PrintingPermission (PermissionState.None);
pp.Level = ppl;
}
public void FromXml_WrongTagCase ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
SecurityElement se = pp.ToXml ();
se.Tag = "IPERMISSION"; // instead of IPermission
pp.FromXml (se);
// note: normally IPermission classes (in corlib) DO care about the
// IPermission tag
}
public void PrintingPermissionLevels_Bad ()
{
PrintingPermissionLevel ppl = (PrintingPermissionLevel)(PrintingPermissionLevel.AllPrinting + 1);
PrintingPermission pp = new PrintingPermission (ppl);
}
public void FromXml_WrongClass ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
SecurityElement se = pp.ToXml ();
SecurityElement w = new SecurityElement (se.Tag);
w.AddAttribute ("class", "Wrong" + se.Attribute ("class"));
w.AddAttribute ("version", se.Attribute ("version"));
pp.FromXml (w);
// doesn't care of the class name at that stage
// anyway the class has already be created so...
}
public void Union_Null ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
// Union with null is a simple copy
foreach (PrintingPermissionLevel ppl in AllLevel) {
pp.Level = ppl;
PrintingPermission union = (PrintingPermission)pp.Union (null);
Assert.AreEqual (ppl, union.Level, ppl.ToString ());
}
}
public void IsSubset_Null ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
Assert.IsTrue (pp.IsSubsetOf (null), "NoLevel");
foreach (PrintingPermissionLevel ppl in AllLevelExceptNoLevel) {
pp.Level = ppl;
Assert.IsFalse (pp.IsSubsetOf (null), ppl.ToString ());
}
}
private static Rect GetImageableRect(PrintDialog dialog)
{
Invariant.Assert(dialog != null, "Dialog should not be null.");
PrintQueue queue = null;
PrintCapabilities capabilities = null;
PageImageableArea imageableArea = null;
Rect imageableRect = Rect.Empty;
// This gets the PringDocumentImageableArea.OriginWidth/OriginHeight
// of the PrintQueue the user chose in the dialog.
CodeAccessPermission printp = new System.Drawing.Printing.PrintingPermission(PrintingPermissionLevel.DefaultPrinting);
printp.Assert();//Blessed Assert to get PrintQueue and call GetPrintCapabilities
try
{
queue = dialog.PrintQueue;
if (queue != null)
{
capabilities = queue.GetPrintCapabilities();
}
}
finally
{
CodeAccessPermission.RevertAssert();
}
if (capabilities != null)
{
imageableArea = capabilities.PageImageableArea;
if (imageableArea != null)
{
imageableRect = new Rect(imageableArea.OriginWidth,
imageableArea.OriginHeight,
imageableArea.ExtentWidth,
imageableArea.ExtentHeight);
}
}
// If for any reason we couldn't get the actual printer's values
// we fallback to a constant and the values available from the
// PrintDialog.
if (imageableRect == Rect.Empty)
{
imageableRect = new Rect(NON_PRINTABLE_MARGIN,
NON_PRINTABLE_MARGIN,
dialog.PrintableAreaWidth,
dialog.PrintableAreaHeight);
}
return imageableRect;
}
public void Union_None ()
{
// Union with none is same
PrintingPermission pp1 = new PrintingPermission (PermissionState.None);
PrintingPermission pp2 = new PrintingPermission (PermissionState.None);
PrintingPermission union = null;
// a. source (this) is none
pp2.Level = PrintingPermissionLevel.NoPrinting;
union = (PrintingPermission)pp1.Union (pp2);
Assert.IsNull (union, "target NoPrinting");
foreach (PrintingPermissionLevel ppl in AllLevelExceptNoAndAllLevel) {
pp2.Level = ppl;
union = (PrintingPermission)pp1.Union (pp2);
Assert.IsFalse (union.IsUnrestricted (), "target " + ppl.ToString ());
}
pp2.Level = PrintingPermissionLevel.AllPrinting;
union = (PrintingPermission)pp1.Union (pp2);
Assert.IsTrue (union.IsUnrestricted (), "target AllPrinting");
// b. destination (target) is none
pp2.Level = PrintingPermissionLevel.NoPrinting;
union = (PrintingPermission)pp2.Union (pp1);
Assert.IsNull (union, "source NoPrinting");
foreach (PrintingPermissionLevel ppl in AllLevelExceptNoAndAllLevel) {
pp2.Level = ppl;
union = (PrintingPermission)pp2.Union (pp1);
Assert.IsFalse (union.IsUnrestricted (), "source " + ppl.ToString ());
}
pp2.Level = PrintingPermissionLevel.AllPrinting;
union = (PrintingPermission)pp2.Union (pp1);
Assert.IsTrue (union.IsUnrestricted (), "source AllPrinting");
}
public void Union_Self ()
{
PrintingPermission pp = new PrintingPermission (PermissionState.None);
foreach (PrintingPermissionLevel ppl in AllLevelExceptNoLevel) {
pp.Level = ppl;
PrintingPermission result = (PrintingPermission)pp.Union (pp);
Assert.AreEqual (ppl, result.Level, ppl.ToString ());
}
// union of NoPrinting with NoPrinting == null
pp.Level = PrintingPermissionLevel.NoPrinting;
Assert.IsNull (pp.Union (pp), "NoPrinting");
}
protected override IStackWalk CreateStackWalk()
{
PrintingPermission permission = new PrintingPermission(PermissionState.Unrestricted);
permission.Level = attribute.Level;
return permission;
}
