/// <summary>Determines whether the current permission is a subset of the specified permission.</summary>
/// <param name="target">A permission to test for the subset relationship. This permission must be the same type as the current permission. </param>
/// <returns>
/// <see langword="true" /> if the current permission is a subset of the specified permission; otherwise, <see langword="false" />.</returns>
/// <exception cref="T:System.ArgumentException">The <paramref name="target" /> parameter is not <see langword="null" /> and is not of the same type as the current permission. </exception>
// Token: 0x0600265E RID: 9822 RVA: 0x0008ACE8 File Offset: 0x00088EE8
public override bool IsSubsetOf(IPermission target)
{
if (target == null)
{
return(this.m_windowFlag == UIPermissionWindow.NoWindows && this.m_clipboardFlag == UIPermissionClipboard.NoClipboard);
}
bool result;
try
{
UIPermission uipermission = (UIPermission)target;
if (uipermission.IsUnrestricted())
{
result = true;
}
else if (this.IsUnrestricted())
{
result = false;
}
else
{
result = (this.m_windowFlag <= uipermission.m_windowFlag && this.m_clipboardFlag <= uipermission.m_clipboardFlag);
}
}
catch (InvalidCastException)
{
throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[]
{
base.GetType().FullName
}));
}
return(result);
}
public void UIPermission_Clipboard_All ()
{
UIPermission uip = new UIPermission (UIPermissionClipboard.AllClipboard);
Assert.AreEqual (UIPermissionClipboard.AllClipboard, uip.Clipboard, "Clipboard");
Assert.AreEqual (UIPermissionWindow.NoWindows, uip.Window, "Window");
Assert.IsFalse (uip.IsUnrestricted (), "IsUnrestricted");
}
public override bool IsSubsetOf(IPermission target)
{
bool flag;
if (target == null)
{
return((this.m_windowFlag == UIPermissionWindow.NoWindows) && (this.m_clipboardFlag == UIPermissionClipboard.NoClipboard));
}
try
{
UIPermission permission = (UIPermission)target;
if (permission.IsUnrestricted())
{
return(true);
}
if (this.IsUnrestricted())
{
return(false);
}
flag = (this.m_windowFlag <= permission.m_windowFlag) && (this.m_clipboardFlag <= permission.m_clipboardFlag);
}
catch (InvalidCastException)
{
throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[] { base.GetType().FullName }));
}
return(flag);
}
public override IPermission Intersect(IPermission target)
{
if (target == null)
{
return(null);
}
else if (!VerifyType(target))
{
throw new
ArgumentException(
String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName)
);
}
UIPermission operand = (UIPermission)target;
UIPermissionWindow isectWindowFlags = m_windowFlag < operand.m_windowFlag ? m_windowFlag : operand.m_windowFlag;
UIPermissionClipboard isectClipboardFlags = m_clipboardFlag < operand.m_clipboardFlag ? m_clipboardFlag : operand.m_clipboardFlag;
if (isectWindowFlags == UIPermissionWindow.NoWindows && isectClipboardFlags == UIPermissionClipboard.NoClipboard)
{
return(null);
}
else
{
return(new UIPermission(isectWindowFlags, isectClipboardFlags));
}
}
/// <summary>确定当前权限是否为指定权限的子集。</summary>
/// <returns>如果当前权限是指定权限的子集，则为 true；否则为 false。</returns>
/// <param name="target">要测试子集关系的权限。此权限必须与当前权限属于同一类型。</param>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="target" /> 参数不是 null，而且与当前权限不是同一类型。</exception>
public override bool IsSubsetOf(IPermission target)
{
if (target == null)
{
if (this.m_windowFlag == UIPermissionWindow.NoWindows)
{
return(this.m_clipboardFlag == UIPermissionClipboard.NoClipboard);
}
return(false);
}
try
{
UIPermission uiPermission = (UIPermission)target;
if (uiPermission.IsUnrestricted())
{
return(true);
}
if (this.IsUnrestricted())
{
return(false);
}
return(this.m_windowFlag <= uiPermission.m_windowFlag && this.m_clipboardFlag <= uiPermission.m_clipboardFlag);
}
catch (InvalidCastException ex)
{
throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", (object)this.GetType().FullName));
}
}
/// <summary>用指定的窗口和剪贴板权限初始化 <see cref="T:System.Security.Permissions.UIPermission" /> 类的新实例。</summary>
/// <param name="windowFlag">枚举值之一。</param>
/// <param name="clipboardFlag">枚举值之一。</param>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="windowFlag" /> 参数不是有效的 <see cref="T:System.Security.Permissions.UIPermissionWindow" /> 值。- 或 -<paramref name="clipboardFlag" /> 参数不是有效的 <see cref="T:System.Security.Permissions.UIPermissionClipboard" /> 值。</exception>
public UIPermission(UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag)
{
UIPermission.VerifyWindowFlag(windowFlag);
UIPermission.VerifyClipboardFlag(clipboardFlag);
this.m_windowFlag = windowFlag;
this.m_clipboardFlag = clipboardFlag;
}
protected override IStackWalk CreateStackWalk()
{
UIPermission permission = new UIPermission(PermissionState.Unrestricted);
permission.Clipboard = attribute.Clipboard;
permission.Window = attribute.Window;
return permission;
}
public void SetClipboardSettings() {
try {
var permission = new UIPermission(UIPermissionClipboard.AllClipboard);
if (Clipboard.ContainsData("UPDATEDATAv3")) {
var rawClipboarData = (string) Clipboard.GetData("UPDATEDATAv3");
var clipboardData = new Dictionary<string, string>();
foreach (string dataItem in rawClipboarData.Split(new[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries)) {
clipboardData.Add(
dataItem.Split(new[] {'#'})[0],
dataItem.Split(new[] {'#'})[1]
);
}
//UpdateURL = clipboardData["updateUrl"];
ProjektID = clipboardData["projectId"];
PublicKey = clipboardData["publicKey"];
}
else
MessageBox.Show("Es konnten keine Updateinformationen in der Zwischenablage gefunden werden.", "updateSystem.NET",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
RefreshDesigner();
}
catch (Exception ex) {
MessageBox.Show(
string.Format("Die Updateeinstellungen konnten aufgrund eines Fehlers nicht übernommen werden:\r\n{0}", ex.ToString()),
"updateSystem.Net", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
//------------------------------------------------------
//
// IPERMISSION IMPLEMENTATION
//
//------------------------------------------------------
public override bool IsSubsetOf(IPermission target)
{
if (target == null)
{
// Only safe subset if this is empty
return(m_windowFlag == UIPermissionWindow.NoWindows && m_clipboardFlag == UIPermissionClipboard.NoClipboard);
}
try
{
UIPermission operand = (UIPermission)target;
if (operand.IsUnrestricted())
{
return(true);
}
else if (this.IsUnrestricted())
{
return(false);
}
else
{
return(this.m_windowFlag <= operand.m_windowFlag && this.m_clipboardFlag <= operand.m_clipboardFlag);
}
}
catch (InvalidCastException)
{
throw new
ArgumentException(
Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
);
}
}
public override IPermission Union(IPermission target)
{
if (target == null)
{
return(this.Copy());
}
else if (!VerifyType(target))
{
throw new
ArgumentException(
Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
);
}
UIPermission operand = (UIPermission)target;
UIPermissionWindow isectWindowFlags = m_windowFlag > operand.m_windowFlag ? m_windowFlag : operand.m_windowFlag;
UIPermissionClipboard isectClipboardFlags = m_clipboardFlag > operand.m_clipboardFlag ? m_clipboardFlag : operand.m_clipboardFlag;
if (isectWindowFlags == UIPermissionWindow.NoWindows && isectClipboardFlags == UIPermissionClipboard.NoClipboard)
{
return(null);
}
else
{
return(new UIPermission(isectWindowFlags, isectClipboardFlags));
}
}
// Methods
public override IPermission CreatePermission ()
{
UIPermission perm = null;
if (this.Unrestricted)
perm = new UIPermission (PermissionState.Unrestricted);
else
perm = new UIPermission (window, clipboard);
return perm;
}
/// <summary>Determines whether the current permission is a subset of the specified permission.</summary>
/// <returns>true if the current permission is a subset of the specified permission; otherwise, false.</returns>
/// <param name="target">A permission to test for the subset relationship. This permission must be the same type as the current permission. </param>
/// <exception cref="T:System.ArgumentException">The <paramref name="target" /> parameter is not null and is not of the same type as the current permission. </exception>
public override bool IsSubsetOf(IPermission target)
{
UIPermission uipermission = this.Cast(target);
if (uipermission == null)
{
return(this.IsEmpty(this._window, this._clipboard));
}
return(uipermission.IsUnrestricted() || (this._window <= uipermission._window && this._clipboard <= uipermission._clipboard));
}
/// <summary>Creates and returns a new <see cref="T:System.Security.Permissions.UIPermission" />.</summary>
/// <returns>A <see cref="T:System.Security.Permissions.UIPermission" /> that corresponds to this attribute.</returns>
public override IPermission CreatePermission()
{
UIPermission result;
if (base.Unrestricted)
{
result = new UIPermission(PermissionState.Unrestricted);
}
else
{
result = new UIPermission(this.window, this.clipboard);
}
return(result);
}
// Methods
public override IPermission CreatePermission()
{
UIPermission perm = null;
if (this.Unrestricted)
{
perm = new UIPermission(PermissionState.Unrestricted);
}
else
{
perm = new UIPermission(window, clipboard);
}
return(perm);
}
private UIPermission Cast(IPermission target)
{
if (target == null)
{
return(null);
}
UIPermission uipermission = target as UIPermission;
if (uipermission == null)
{
CodeAccessPermission.ThrowInvalidPermission(target, typeof(UIPermission));
}
return(uipermission);
}
public void PermissionStateUnrestricted ()
{
UIPermission uip = new UIPermission (PermissionState.Unrestricted);
Assert.AreEqual (UIPermissionClipboard.AllClipboard, uip.Clipboard, "Clipboard");
Assert.AreEqual (UIPermissionWindow.AllWindows, uip.Window, "Window");
Assert.IsTrue (uip.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = uip.ToXml ();
Assert.AreEqual ("true", se.Attribute ("Unrestricted"), "Xml-Unrestricted");
UIPermission copy = (UIPermission)uip.Copy ();
Assert.AreEqual (UIPermissionClipboard.AllClipboard, uip.Clipboard, "Copy-Clipboard");
Assert.AreEqual (UIPermissionWindow.AllWindows, uip.Window, "Copy-Window");
Assert.IsTrue (uip.IsUnrestricted (), "Copy-IsUnrestricted");
}
public void PermissionStateNone ()
{
UIPermission uip = new UIPermission (PermissionState.None);
Assert.AreEqual (UIPermissionClipboard.NoClipboard, uip.Clipboard, "Clipboard");
Assert.AreEqual (UIPermissionWindow.NoWindows, uip.Window, "Window");
Assert.IsFalse (uip.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = uip.ToXml ();
Assert.IsNull (se.Attribute ("Unrestricted"), "Xml-Unrestricted");
UIPermission copy = (UIPermission)uip.Copy ();
Assert.AreEqual (UIPermissionClipboard.NoClipboard, uip.Clipboard, "Copy-Clipboard");
Assert.AreEqual (UIPermissionWindow.NoWindows, uip.Window, "Copy-Window");
Assert.IsFalse (uip.IsUnrestricted (), "Copy-IsUnrestricted");
}
public override bool IsSubsetOf(IPermission target)
{
UIPermission uip = Cast(target);
if (uip == null)
{
return(IsEmpty(_window, _clipboard));
}
if (uip.IsUnrestricted())
{
return(true);
}
// there are not [Flags] so we can't use boolean operators
return((_window <= uip._window) && (_clipboard <= uip._clipboard));
}
private UIPermission Cast(IPermission target)
{
if (target == null)
{
return(null);
}
UIPermission uip = (target as UIPermission);
if (uip == null)
{
ThrowInvalidPermission(target, typeof(UIPermission));
}
return(uip);
}
/// <summary>Creates a permission that is the union of the permission and the specified permission.</summary>
/// <returns>A new permission that represents the union of the current permission and the specified permission.</returns>
/// <param name="target">A permission to combine with the current permission. It must be the same type as the current permission. </param>
/// <exception cref="T:System.ArgumentException">The <paramref name="target" /> parameter is not null and is not of the same type as the current permission. </exception>
public override IPermission Union(IPermission target)
{
UIPermission uipermission = this.Cast(target);
if (uipermission == null)
{
return(this.Copy());
}
UIPermissionWindow uipermissionWindow = (this._window <= uipermission._window) ? uipermission._window : this._window;
UIPermissionClipboard uipermissionClipboard = (this._clipboard <= uipermission._clipboard) ? uipermission._clipboard : this._clipboard;
if (this.IsEmpty(uipermissionWindow, uipermissionClipboard))
{
return(null);
}
return(new UIPermission(uipermissionWindow, uipermissionClipboard));
}
public override IPermission Intersect(IPermission target)
{
if (target == null)
{
return(null);
}
if (!base.VerifyType(target))
{
throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[] { base.GetType().FullName }));
}
UIPermission permission = (UIPermission)target;
UIPermissionWindow windowFlag = (this.m_windowFlag < permission.m_windowFlag) ? this.m_windowFlag : permission.m_windowFlag;
UIPermissionClipboard clipboardFlag = (this.m_clipboardFlag < permission.m_clipboardFlag) ? this.m_clipboardFlag : permission.m_clipboardFlag;
if ((windowFlag == UIPermissionWindow.NoWindows) && (clipboardFlag == UIPermissionClipboard.NoClipboard))
{
return(null);
}
return(new UIPermission(windowFlag, clipboardFlag));
}
/// <summary>创建一个权限，该权限是当前权限和指定权限的并集。</summary>
/// <returns>一个新权限，它表示当前权限与指定权限的并集。</returns>
/// <param name="target">将与当前权限合并的权限。它必须与当前权限属于同一类型。</param>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="target" /> 参数不是 null，而且与当前权限不是同一类型。</exception>
public override IPermission Union(IPermission target)
{
if (target == null)
{
return(this.Copy());
}
if (!this.VerifyType(target))
{
throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", (object)this.GetType().FullName));
}
UIPermission uiPermission = (UIPermission)target;
UIPermissionWindow windowFlag = this.m_windowFlag > uiPermission.m_windowFlag ? this.m_windowFlag : uiPermission.m_windowFlag;
UIPermissionClipboard clipboardFlag = this.m_clipboardFlag > uiPermission.m_clipboardFlag ? this.m_clipboardFlag : uiPermission.m_clipboardFlag;
if (windowFlag == UIPermissionWindow.NoWindows && clipboardFlag == UIPermissionClipboard.NoClipboard)
{
return((IPermission)null);
}
return((IPermission) new UIPermission(windowFlag, clipboardFlag));
}
public override IPermission Union(IPermission target)
{
UIPermission uip = Cast(target);
if (uip == null)
{
return(Copy());
}
// there are not [Flags] so we can't use boolean operators
UIPermissionWindow w = ((_window > uip._window) ? _window : uip._window);
UIPermissionClipboard c = ((_clipboard > uip._clipboard) ? _clipboard : uip._clipboard);
if (IsEmpty(w, c))
{
return(null);
}
return(new UIPermission(w, c));
}
/// <summary>Creates a permission that is the union of the permission and the specified permission.</summary>
/// <param name="target">A permission to combine with the current permission. It must be the same type as the current permission. </param>
/// <returns>A new permission that represents the union of the current permission and the specified permission.</returns>
/// <exception cref="T:System.ArgumentException">The <paramref name="target" /> parameter is not <see langword="null" /> and is not of the same type as the current permission. </exception>
// Token: 0x06002660 RID: 9824 RVA: 0x0008AE18 File Offset: 0x00089018
public override IPermission Union(IPermission target)
{
if (target == null)
{
return(this.Copy());
}
if (!base.VerifyType(target))
{
throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[]
{
base.GetType().FullName
}));
}
UIPermission uipermission = (UIPermission)target;
UIPermissionWindow uipermissionWindow = (this.m_windowFlag > uipermission.m_windowFlag) ? this.m_windowFlag : uipermission.m_windowFlag;
UIPermissionClipboard uipermissionClipboard = (this.m_clipboardFlag > uipermission.m_clipboardFlag) ? this.m_clipboardFlag : uipermission.m_clipboardFlag;
if (uipermissionWindow == UIPermissionWindow.NoWindows && uipermissionClipboard == UIPermissionClipboard.NoClipboard)
{
return(null);
}
return(new UIPermission(uipermissionWindow, uipermissionClipboard));
}
public void FromXml_NoVersion ()
{
UIPermission uip = new UIPermission (PermissionState.None);
SecurityElement se = uip.ToXml ();
SecurityElement w = new SecurityElement (se.Tag);
w.AddAttribute ("class", se.Attribute ("class"));
uip.FromXml (w);
}
private void Compare (UIPermission uip1, UIPermission uip2, string prefix)
{
Assert.AreEqual (uip1.Clipboard, uip2.Clipboard, prefix + ".Clipboard");
Assert.AreEqual (uip1.Window, uip2.Window, prefix + ".Window");
Assert.AreEqual (uip1.IsUnrestricted (), uip2.IsUnrestricted (), prefix + ".IsUnrestricted ()");
}
/// <summary>
/// Filters out a message before it is dispatched
/// </summary>
/// <param name="m">The message to be dispatched. You cannot modify
/// this message</param>
/// <returns>true to filter the message and prevent it from being
/// dispatched; false to allow the message to continue to the next
/// filter or control</returns>
public bool PreFilterMessage(ref Message m)
{
// make sure we have a client
if (this.Client == null)
{
return false;
}
// make sure the message is a key message
if (m.Msg != (int) WindowMessage.WM_KEYDOWN && m.Msg != (int) WindowMessage.WM_SYSKEYDOWN &&
m.Msg != (int) WindowMessage.WM_KEYUP && m.Msg != (int) WindowMessage.WM_SYSKEYUP)
{
return false;
}
// try to get the target control
UIPermission uiPermission = new UIPermission(UIPermissionWindow.AllWindows);
uiPermission.Demand();
Control target = Control.FromChildHandle(m.HWnd);
return this.Client.ProcessKeyMessage(target, (WindowMessage) m.Msg, m.WParam.ToInt32(), m.LParam.ToInt32());
}
public void UIPermission_Windows_SafeTopLevelWindows ()
{
UIPermission uip = new UIPermission (UIPermissionWindow.SafeTopLevelWindows);
Assert.AreEqual (UIPermissionClipboard.NoClipboard, uip.Clipboard, "Clipboard");
Assert.AreEqual (UIPermissionWindow.SafeTopLevelWindows, uip.Window, "Window");
Assert.IsFalse (uip.IsUnrestricted (), "IsUnrestricted");
}
public void Window_Bad ()
{
UIPermission uip = new UIPermission (PermissionState.None);
uip.Window = (UIPermissionWindow) 128;
}
internal override void CreateAllStyle()
{
Invariant.Assert(App != null, "RootBrowserWindow must be created in an Application");
IHostService ihs = (IHostService)App.GetService(typeof(IHostService));
Invariant.Assert(ihs!=null, "IHostService in RootBrowserWindow cannot be null");
Invariant.Assert(ihs.HostWindowHandle != IntPtr.Zero, "IHostService.HostWindowHandle in RootBrowserWindow cannot be null");
//This sets the _ownerHandle correctly and will be used to create the _sourceWindow
//with the correct parent
UIPermission uip = new UIPermission(UIPermissionWindow.AllWindows);
uip.Assert();//Blessed Assert to set owner handle and to set styles
try
{
this.OwnerHandle = ihs.HostWindowHandle;
this.Win32Style = NativeMethods.WS_CHILD | NativeMethods.WS_CLIPCHILDREN | NativeMethods.WS_CLIPSIBLINGS;
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
public void Union_DifferentPermissions ()
{
UIPermission a = new UIPermission (PermissionState.None);
SecurityPermission b = new SecurityPermission (PermissionState.None);
a.Union (b);
}
public void ResolveWithChildren ()
{
PermissionSet pset1 = new PermissionSet (PermissionState.None);
PermissionSet pset2 = new PermissionSet (PermissionState.None);
PermissionSet pset3 = new PermissionSet (PermissionState.None);
PermissionSet pset4 = new PermissionSet (PermissionState.None);
PermissionSet pset5 = new PermissionSet (PermissionState.None);
PermissionSet pset6 = new PermissionSet (PermissionState.None);
IPermission perm1 = new UIPermission (PermissionState.Unrestricted);
IPermission perm2 = new EnvironmentPermission (PermissionState.Unrestricted);
IPermission perm3 = new FileDialogPermission (PermissionState.Unrestricted);
IPermission perm4 = new ReflectionPermission (PermissionState.Unrestricted);
IPermission perm5 = new RegistryPermission (PermissionState.Unrestricted);
IPermission perm6 = new FileIOPermission (PermissionState.Unrestricted);
pset1.AddPermission (perm1);
PolicyStatement policy1 = new PolicyStatement (pset1);
pset2.AddPermission(perm2);
PolicyStatement policy2 = new PolicyStatement (pset2);
pset3.AddPermission (perm3);
PolicyStatement policy3 = new PolicyStatement (pset3);
pset4.AddPermission (perm4);
PolicyStatement policy4 = new PolicyStatement (pset4);
pset5.AddPermission (perm5);
PolicyStatement policy5 = new PolicyStatement (pset5);
pset6.AddPermission (perm6);
PolicyStatement policy6 = new PolicyStatement (pset6);
UnionCodeGroup root = new UnionCodeGroup (new AllMembershipCondition (), policy1);
UnionCodeGroup child1 = new UnionCodeGroup (new ZoneMembershipCondition (SecurityZone.Internet), policy2);
UnionCodeGroup child2 = new UnionCodeGroup (new AllMembershipCondition (), policy3);
UnionCodeGroup child3 = new UnionCodeGroup (new AllMembershipCondition (), policy4);
UnionCodeGroup childofchild1 = new UnionCodeGroup (new AllMembershipCondition (), policy5);
UnionCodeGroup childofchild3 = new UnionCodeGroup (new AllMembershipCondition (), policy6);
child1.AddChild (childofchild1);
child3.AddChild (childofchild3);
root.AddChild (child1);
root.AddChild (child2);
root.AddChild (child3);
PolicyStatement result = root.Resolve (new Evidence ());
PermissionSet correctset = new PermissionSet (PermissionState.None);
correctset.AddPermission (perm1);
correctset.AddPermission (perm3);
correctset.AddPermission (perm4);
correctset.AddPermission (perm6);
Assert.AreEqual (correctset.Count, result.PermissionSet.Count, "PermissionSet.Count");
foreach (IPermission p in correctset) {
IPermission r = result.PermissionSet.GetPermission (p.GetType ());
Assert.IsNotNull (r, "PermissionSet.GetPermission");
}
}
public void FromXml_WrongTagCase ()
{
UIPermission uip = new UIPermission (PermissionState.None);
SecurityElement se = uip.ToXml ();
se.Tag = "IPERMISSION"; // instead of IPermission
uip.FromXml (se);
}
public void FromXml_Null ()
{
UIPermission uip = new UIPermission (PermissionState.None);
uip.FromXml (null);
}
public void FromXml_WrongClass ()
{
UIPermission uip = new UIPermission (PermissionState.None);
SecurityElement se = uip.ToXml ();
SecurityElement w = new SecurityElement (se.Tag);
w.AddAttribute ("class", "Wrong" + se.Attribute ("class"));
w.AddAttribute ("version", se.Attribute ("version"));
uip.FromXml (w);
// doesn't care of the class name at that stage
// anyway the class has already be created so...
}
public void FromXml_NoClass ()
{
UIPermission uip = new UIPermission (PermissionState.None);
SecurityElement se = uip.ToXml ();
SecurityElement w = new SecurityElement (se.Tag);
w.AddAttribute ("version", se.Attribute ("version"));
uip.FromXml (w);
// doesn't even care of the class attribute presence
}
// Loads any steps
protected override void OnLoad(System.EventArgs e)
{
base.OnLoad(e);
if( !DesignMode )
{
OnLoadSteps(EventArgs.Empty);
if( FirstStepName == "" )
throw new InvalidOperationException("FirstStepName must be be a non-empty string.");
ResetSteps();
SetCurrentStep(FirstStepName, StepDirection.InitialStep);
}
else
{
UpdateLayout(currentLayout);
}
UIPermission uiP = new UIPermission(UIPermissionWindow.AllWindows);
uiP.Demand();
}
/// <summary>在具有使用窗口的权限，但没有对剪贴板的访问权限的情况下，初始化 <see cref="T:System.Security.Permissions.UIPermission" /> 类的新实例。</summary>
/// <param name="windowFlag">枚举值之一。</param>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="windowFlag" /> 参数不是有效的 <see cref="T:System.Security.Permissions.UIPermissionWindow" /> 值。</exception>
public UIPermission(UIPermissionWindow windowFlag)
{
UIPermission.VerifyWindowFlag(windowFlag);
this.m_windowFlag = windowFlag;
}
public void Union ()
{
UIPermission none = new UIPermission (PermissionState.None);
UIPermission union = (UIPermission)none.Union (null);
Compare (none, union, "none U null");
Assert.IsFalse (Object.ReferenceEquals (none, union), "!ReferenceEquals1");
Assert.IsTrue (none.IsSubsetOf (union), "none.IsSubsetOf (union)");
union = (UIPermission)none.Union (new UIPermission (PermissionState.None));
Assert.IsNull (union, "none U none");
Assert.IsTrue (none.IsSubsetOf (null), "none.IsSubsetOf (null)");
UIPermission unrestricted = new UIPermission (PermissionState.Unrestricted);
union = (UIPermission)none.Union (unrestricted);
Compare (unrestricted, union, "none U unrestricted");
Assert.IsTrue (union.IsUnrestricted (), "IsUnrestricted-1");
Assert.IsFalse (Object.ReferenceEquals (unrestricted, union), "!ReferenceEquals2");
Assert.IsTrue (none.IsSubsetOf (union), "none.IsSubsetOf (union)");
Assert.IsTrue (unrestricted.IsSubsetOf (union), "unrestricted.IsSubsetOf (union)");
union = (UIPermission)unrestricted.Union (unrestricted);
Compare (unrestricted, union, "unrestricted U unrestricted");
Assert.IsTrue (union.IsUnrestricted (), "IsUnrestricted-2");
Assert.IsFalse (Object.ReferenceEquals (unrestricted, union), "!ReferenceEquals3");
Assert.IsTrue (unrestricted.IsSubsetOf (union), "unrestricted.IsSubsetOf (union)");
UIPermission clip_all = new UIPermission (UIPermissionClipboard.AllClipboard);
UIPermission win_all = new UIPermission (UIPermissionWindow.AllWindows);
union = (UIPermission)clip_all.Union (win_all);
Compare (unrestricted, union, "clip_all U win_all");
Assert.IsTrue (union.IsUnrestricted (), "IsUnrestricted-3");
Assert.IsTrue (clip_all.IsSubsetOf (union), "clip_all.IsSubsetOf (union)");
Assert.IsTrue (win_all.IsSubsetOf (union), "win_all.IsSubsetOf (union)");
}
/// <summary>在具有使用剪贴板的权限，但没有对窗口的访问权限的情况下，初始化 <see cref="T:System.Security.Permissions.UIPermission" /> 类的新实例。</summary>
/// <param name="clipboardFlag">枚举值之一。</param>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="clipboardFlag" /> 参数不是有效的 <see cref="T:System.Security.Permissions.UIPermissionClipboard" /> 值。</exception>
public UIPermission(UIPermissionClipboard clipboardFlag)
{
UIPermission.VerifyClipboardFlag(clipboardFlag);
this.m_clipboardFlag = clipboardFlag;
}
public void IsSubsetOf_DifferentPermissions ()
{
UIPermission a = new UIPermission (PermissionState.None);
SecurityPermission b = new SecurityPermission (PermissionState.None);
a.IsSubsetOf (b);
}
public void Unrestricted ()
{
UIPermission uip = new UIPermission (PermissionState.None);
SecurityElement se = uip.ToXml ();
// attribute value is not case-sensitive
se.AddAttribute ("Unrestricted", "TRUE");
uip.FromXml (se);
Assert.IsTrue (uip.IsUnrestricted (), "IsUnrestricted-TRUE");
uip = new UIPermission (PermissionState.None);
// attribute name is not case-sensitive either!!!
se.AddAttribute ("UNRESTRICTED", "TRUE");
uip.FromXml (se);
Assert.IsTrue (uip.IsUnrestricted (), "IsUnrestricted-UPPER");
}
public void IsSubsetOf ()
{
UIPermission unrestricted = new UIPermission (PermissionState.Unrestricted);
UIPermission empty = new UIPermission (PermissionState.None);
Assert.IsFalse (unrestricted.IsSubsetOf (empty), "unrestricted.IsSubsetOf (empty)");
Assert.IsTrue (empty.IsSubsetOf (unrestricted), "empty.IsSubsetOf (unrestricted)");
Assert.IsTrue (empty.IsSubsetOf (null), "empty.IsSubsetOf (null)");
Assert.IsFalse (unrestricted.IsSubsetOf (null), "unrestricted.IsSubsetOf (null)");
}
[System.Security.SecurityCritical] // auto-generated
private static void ValidateCspFlags (CspProviderFlags flags) {
// check that the flags are consistent.
if ((flags & CspProviderFlags.UseExistingKey) != 0) {
CspProviderFlags keyFlags = (CspProviderFlags.UseNonExportableKey | CspProviderFlags.UseArchivableKey | CspProviderFlags.UseUserProtectedKey);
if ((flags & keyFlags) != CspProviderFlags.NoFlags)
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag"));
}
// make sure we are allowed to display the key protection UI if a user protected key is requested.
if ((flags & CspProviderFlags.UseUserProtectedKey) != 0) {
// UI only allowed in interactive session.
if (!System.Environment.UserInteractive)
throw new InvalidOperationException(Environment.GetResourceString("Cryptography_NotInteractive"));
// we need to demand UI permission here.
UIPermission uiPermission = new UIPermission(UIPermissionWindow.SafeTopLevelWindows);
uiPermission.Demand();
}
}
/// <summary>
/// Filters out a message before it is dispatched
/// </summary>
/// <param name="m">The message to be dispatched. You cannot modify
/// this message</param>
/// <returns>true to filter the message and prevent it from being
/// dispatched; false to allow the message to continue to the next
/// filter or control</returns>
public bool PreFilterMessage(ref Message m)
{
// make sure we have a client
if (this.Client == null)
{
return false;
}
// make sure the message is a mouse message
if ((m.Msg >= (int) WindowMessage.WM_MOUSEMOVE && m.Msg <= (int) WindowMessage.WM_XBUTTONDBLCLK) ||
(m.Msg >= (int) WindowMessage.WM_NCMOUSEMOVE && m.Msg <= (int) WindowMessage.WM_NCXBUTTONUP))
{
// try to get the target control
UIPermission uiPermission = new UIPermission(UIPermissionWindow.AllWindows);
uiPermission.Demand();
Control target = Control.FromChildHandle(m.HWnd);
return this.Client.ProcessMouseMessage(target, (WindowMessage) m.Msg, m.WParam, m.LParam);
}
return false;
}
public void Clipboard_Bad ()
{
UIPermission uip = new UIPermission (PermissionState.None);
uip.Clipboard = (UIPermissionClipboard) 128;
}
public void Intersect_DifferentPermissions ()
{
UIPermission a = new UIPermission (PermissionState.None);
SecurityPermission b = new SecurityPermission (PermissionState.None);
a.Intersect (b);
}
public void UIPermission_Windows_Bad ()
{
UIPermission uip = new UIPermission ((UIPermissionWindow)128);
}
public void Intersect ()
{
UIPermission clip_all = new UIPermission (UIPermissionClipboard.AllClipboard);
UIPermission clip_own = new UIPermission (UIPermissionClipboard.OwnClipboard);
UIPermission intersect = (UIPermission)clip_all.Intersect (clip_own);
Compare (clip_own, intersect, "clip_all N clip_own");
Assert.IsFalse (Object.ReferenceEquals (clip_own, intersect), "!ReferenceEquals1");
Assert.IsTrue (intersect.IsSubsetOf (clip_all), "intersect.IsSubsetOf (clip_all)");
Assert.IsTrue (intersect.IsSubsetOf (clip_own), "intersect.IsSubsetOf (clip_own)");
UIPermission win_all = new UIPermission (UIPermissionWindow.AllWindows);
UIPermission win_safe = new UIPermission (UIPermissionWindow.SafeSubWindows);
intersect = (UIPermission) win_all.Intersect (win_safe);
Compare (win_safe, intersect, "win_all N win_safe");
Assert.IsFalse (Object.ReferenceEquals (win_safe, intersect), "!ReferenceEquals2");
Assert.IsTrue (intersect.IsSubsetOf (win_all), "intersect.IsSubsetOf (win_all)");
Assert.IsTrue (intersect.IsSubsetOf (win_safe), "intersect.IsSubsetOf (win_safe)");
intersect = (UIPermission)win_all.Intersect (clip_all);
Assert.IsNull (intersect, "win_all N clip_all");
intersect = (UIPermission)win_all.Intersect (null);
Assert.IsNull (intersect, "win_all N null");
intersect = (UIPermission)clip_all.Intersect (null);
Assert.IsNull (intersect, "clip_all N null");
UIPermission empty = new UIPermission (PermissionState.None);
intersect = (UIPermission)clip_all.Intersect (empty);
Assert.IsNull (intersect, "clip_all N null");
UIPermission unrestricted = new UIPermission (PermissionState.Unrestricted);
intersect = (UIPermission)clip_all.Intersect (unrestricted);
Compare (clip_all, intersect, "clip_all N unrestricted");
Assert.IsFalse (Object.ReferenceEquals (clip_all, intersect), "!ReferenceEquals4");
Assert.IsTrue (intersect.IsSubsetOf (clip_all), "intersect.IsSubsetOf (clip_all)");
Assert.IsTrue (intersect.IsSubsetOf (unrestricted), "intersect.IsSubsetOf (unrestricted)");
}
/// <internalonly/>
int IBuiltInPermission.GetTokenIndex()
{
return(UIPermission.GetTokenIndex());
}
public void PermissionStateInvalid ()
{
UIPermission uip = new UIPermission ((PermissionState)2);
}
