// Constructors
public UIPermission (PermissionState state)
{
if (CheckPermissionState (state, true) == PermissionState.Unrestricted) {
_clipboard = UIPermissionClipboard.AllClipboard;
_window = UIPermissionWindow.AllWindows;
}
}
private static void VerifyWindowFlag(UIPermissionWindow flag)
{
if ((flag < UIPermissionWindow.NoWindows) || (flag > UIPermissionWindow.AllWindows))
{
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[] { (int)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));
}
}
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.ValidateElement(esd, this);
if (XMLUtil.IsUnrestricted(esd))
{
SetUnrestricted(true);
return;
}
m_windowFlag = UIPermissionWindow.NoWindows;
m_clipboardFlag = UIPermissionClipboard.NoClipboard;
String window = esd.Attribute("Window");
if (window != null)
{
m_windowFlag = (UIPermissionWindow)Enum.Parse(typeof(UIPermissionWindow), window);
}
String clipboard = esd.Attribute("Clipboard");
if (clipboard != null)
{
m_clipboardFlag = (UIPermissionClipboard)Enum.Parse(typeof(UIPermissionClipboard), clipboard);
}
}
public override void FromXml(SecurityElement esd)
{
// General validation in CodeAccessPermission
CheckSecurityElement(esd, "esd", version, version);
// Note: we do not (yet) care about the return value
// as we only accept version 1 (min/max values)
if (IsUnrestricted(esd))
{
_window = UIPermissionWindow.AllWindows;
_clipboard = UIPermissionClipboard.AllClipboard;
}
else
{
string w = esd.Attribute("Window");
if (w == null)
{
_window = UIPermissionWindow.NoWindows;
}
else
{
_window = (UIPermissionWindow)Enum.Parse(typeof(UIPermissionWindow), w);
}
string c = esd.Attribute("Clipboard");
if (c == null)
{
_clipboard = UIPermissionClipboard.NoClipboard;
}
else
{
_clipboard = (UIPermissionClipboard)Enum.Parse(typeof(UIPermissionClipboard), c);
}
}
}
//------------------------------------------------------
//
// PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
//
//------------------------------------------------------
private static void VerifyWindowFlag(UIPermissionWindow flag)
{
if (flag < UIPermissionWindow.NoWindows || flag > UIPermissionWindow.AllWindows)
{
throw new ArgumentException(String.Format(Environment.GetResourceString("Arg_EnumIllegalVal"), (int)flag));
}
}
public UIPermission(UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag)
{
VerifyWindowFlag(windowFlag);
VerifyClipboardFlag(clipboardFlag);
this.m_windowFlag = windowFlag;
this.m_clipboardFlag = clipboardFlag;
}
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));
}
}
/// <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;
}
/// <summary>Reconstructs a permission with a specified state from an XML encoding.</summary>
/// <param name="esd">The XML encoding used to reconstruct the permission. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="esd" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="esd" /> parameter is not a valid permission element.-or- The <paramref name="esd" /> parameter's version number is not valid. </exception>
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.CheckSecurityElement(esd, "esd", 1, 1);
if (CodeAccessPermission.IsUnrestricted(esd))
{
this._window = UIPermissionWindow.AllWindows;
this._clipboard = UIPermissionClipboard.AllClipboard;
}
else
{
string text = esd.Attribute("Window");
if (text == null)
{
this._window = UIPermissionWindow.NoWindows;
}
else
{
this._window = (UIPermissionWindow)((int)Enum.Parse(typeof(UIPermissionWindow), text));
}
string text2 = esd.Attribute("Clipboard");
if (text2 == null)
{
this._clipboard = UIPermissionClipboard.NoClipboard;
}
else
{
this._clipboard = (UIPermissionClipboard)((int)Enum.Parse(typeof(UIPermissionClipboard), text2));
}
}
}
//------------------------------------------------------
//
// PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
//
//------------------------------------------------------
private static void VerifyWindowFlag(UIPermissionWindow flag)
{
if (flag < UIPermissionWindow.NoWindows || flag > UIPermissionWindow.AllWindows)
{
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)flag));
}
Contract.EndContractBlock();
}
private void SetUnrestricted(bool unrestricted)
{
if (unrestricted)
{
m_windowFlag = UIPermissionWindow.AllWindows;
m_clipboardFlag = UIPermissionClipboard.AllClipboard;
}
}
// Constructors
public UIPermission(PermissionState state)
{
if (CheckPermissionState(state, true) == PermissionState.Unrestricted)
{
_clipboard = UIPermissionClipboard.AllClipboard;
_window = UIPermissionWindow.AllWindows;
}
}
public UIPermission(UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag)
{
VerifyWindowFlag(windowFlag);
VerifyClipboardFlag(clipboardFlag);
m_windowFlag = windowFlag;
m_clipboardFlag = clipboardFlag;
}
/// <summary>Initializes a new instance of the <see cref="T:System.Security.Permissions.UIPermission" /> class with either fully restricted or unrestricted access, as specified.</summary>
/// <param name="state">One of the <see cref="T:System.Security.Permissions.PermissionState" /> values. </param>
/// <exception cref="T:System.ArgumentException">The <paramref name="state" /> parameter is not a valid <see cref="T:System.Security.Permissions.PermissionState" />. </exception>
public UIPermission(PermissionState state)
{
if (CodeAccessPermission.CheckPermissionState(state, true) == PermissionState.Unrestricted)
{
this._clipboard = UIPermissionClipboard.AllClipboard;
this._window = UIPermissionWindow.AllWindows;
}
}
private void SetUnrestricted(bool unrestricted)
{
if (!unrestricted)
{
return;
}
this.m_windowFlag = UIPermissionWindow.AllWindows;
this.m_clipboardFlag = UIPermissionClipboard.AllClipboard;
}
public UIPermission(UIPermissionWindow windowFlag)
{
if (windowFlag < UIPermissionWindow.NoWindows ||
windowFlag > UIPermissionWindow.AllWindows)
{
throw new ArgumentException(_("Arg_WindowFlag"));
}
window = windowFlag;
clipboard = UIPermissionClipboard.NoClipboard;
}
public UIPermission(UIPermissionClipboard clipboardFlag)
{
if (clipboardFlag < UIPermissionClipboard.NoClipboard ||
clipboardFlag > UIPermissionClipboard.AllClipboard)
{
throw new ArgumentException(_("Arg_ClipboardFlag"));
}
window = UIPermissionWindow.NoWindows;
clipboard = clipboardFlag;
}
public UIPermission(UIPermissionClipboard clipboardFlag)
{
if(clipboardFlag < UIPermissionClipboard.NoClipboard ||
clipboardFlag > UIPermissionClipboard.AllClipboard)
{
throw new ArgumentException(_("Arg_ClipboardFlag"));
}
window = UIPermissionWindow.NoWindows;
clipboard = clipboardFlag;
}
public UIPermission(UIPermissionWindow windowFlag)
{
if(windowFlag < UIPermissionWindow.NoWindows ||
windowFlag > UIPermissionWindow.AllWindows)
{
throw new ArgumentException(_("Arg_WindowFlag"));
}
window = windowFlag;
clipboard = UIPermissionClipboard.NoClipboard;
}
// Constructors.
public UIPermission(PermissionState state)
{
if(state == PermissionState.None)
{
window = UIPermissionWindow.NoWindows;
clipboard = UIPermissionClipboard.NoClipboard;
}
else if(state == PermissionState.Unrestricted)
{
window = UIPermissionWindow.AllWindows;
clipboard = UIPermissionClipboard.AllClipboard;
}
else
{
throw new ArgumentException(_("Arg_PermissionState"));
}
}
// Constructors.
public UIPermission(PermissionState state)
{
if (state == PermissionState.None)
{
window = UIPermissionWindow.NoWindows;
clipboard = UIPermissionClipboard.NoClipboard;
}
else if (state == PermissionState.Unrestricted)
{
window = UIPermissionWindow.AllWindows;
clipboard = UIPermissionClipboard.AllClipboard;
}
else
{
throw new ArgumentException(_("Arg_PermissionState"));
}
}
/// <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)
{
// Handle the easy cases first.
if (target == null)
{
return(target);
}
else if (!(target is UIPermission))
{
throw new ArgumentException(_("Arg_PermissionMismatch"));
}
else if (((UIPermission)target)
.IsUnrestricted())
{
return(Copy());
}
else if (IsUnrestricted())
{
return(target.Copy());
}
// Get the minimum flag values.
UIPermissionWindow w = ((UIPermission)target).window;
if (((int)w) > ((int)window))
{
w = window;
}
UIPermissionClipboard c = ((UIPermission)target).clipboard;
if (((int)c) > ((int)clipboard))
{
c = clipboard;
}
// Create a new object for the intersection.
if (w == UIPermissionWindow.NoWindows &&
c == UIPermissionClipboard.NoClipboard)
{
return(null);
}
else
{
return(new UIPermission(w, c));
}
}
// Convert an XML value into a permissions value.
public override void FromXml(SecurityElement esd)
{
String value;
if (esd == null)
{
throw new ArgumentNullException("esd");
}
if (esd.Attribute("version") != "1")
{
throw new ArgumentException(_("Arg_PermissionVersion"));
}
value = esd.Attribute("Unrestricted");
if (value != null && Boolean.Parse(value))
{
window = UIPermissionWindow.NoWindows;
clipboard = UIPermissionClipboard.NoClipboard;
}
else
{
value = esd.Attribute("Window");
if (value != null)
{
window = (UIPermissionWindow)
Enum.Parse(typeof(UIPermissionWindow), value);
}
else
{
window = UIPermissionWindow.NoWindows;
}
value = esd.Attribute("Clipboard");
if (value != null)
{
clipboard = (UIPermissionClipboard)
Enum.Parse(typeof(UIPermissionClipboard), value);
}
else
{
clipboard = UIPermissionClipboard.NoClipboard;
}
}
}
/// <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));
}
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>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 override void FromXml(SecurityElement esd)
{
CodeAccessPermission.ValidateElement(esd, this);
if (XMLUtil.IsUnrestricted(esd))
{
this.SetUnrestricted(true);
}
else
{
this.m_windowFlag = UIPermissionWindow.NoWindows;
this.m_clipboardFlag = UIPermissionClipboard.NoClipboard;
string str = esd.Attribute("Window");
if (str != null)
{
this.m_windowFlag = (UIPermissionWindow) Enum.Parse(typeof(UIPermissionWindow), str);
}
string str2 = esd.Attribute("Clipboard");
if (str2 != null)
{
this.m_clipboardFlag = (UIPermissionClipboard) Enum.Parse(typeof(UIPermissionClipboard), str2);
}
}
}
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.ValidateElement(esd, this);
if (XMLUtil.IsUnrestricted(esd))
{
this.SetUnrestricted(true);
}
else
{
this.m_windowFlag = UIPermissionWindow.NoWindows;
this.m_clipboardFlag = UIPermissionClipboard.NoClipboard;
string str = esd.Attribute("Window");
if (str != null)
{
this.m_windowFlag = (UIPermissionWindow)Enum.Parse(typeof(UIPermissionWindow), str);
}
string str2 = esd.Attribute("Clipboard");
if (str2 != null)
{
this.m_clipboardFlag = (UIPermissionClipboard)Enum.Parse(typeof(UIPermissionClipboard), str2);
}
}
}
public UIPermission(UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag)
{
}
//------------------------------------------------------
//
// PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
//
//------------------------------------------------------
private static void VerifyWindowFlag(UIPermissionWindow flag)
{
if (flag < UIPermissionWindow.NoWindows || flag > UIPermissionWindow.AllWindows)
{
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)flag));
}
Contract.EndContractBlock();
}
public UIPermission(UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag)
{
}
public UIPermission(UIPermissionWindow windowFlag)
{
}
public override void FromXml(SecurityElement esd)
{
CodeAccessPermission.ValidateElement( esd, this );
if (XMLUtil.IsUnrestricted( esd ))
{
SetUnrestricted( true );
return;
}
m_windowFlag = UIPermissionWindow.NoWindows;
m_clipboardFlag = UIPermissionClipboard.NoClipboard;
String window = esd.Attribute( "Window" );
if (window != null)
m_windowFlag = (UIPermissionWindow)Enum.Parse( typeof( UIPermissionWindow ), window );
String clipboard = esd.Attribute( "Clipboard" );
if (clipboard != null)
m_clipboardFlag = (UIPermissionClipboard)Enum.Parse( typeof( UIPermissionClipboard ), clipboard );
}
public UIPermission(UIPermissionWindow windowFlag)
{
}
// Convert an XML value into a permissions value.
public override void FromXml(SecurityElement esd)
{
String value;
if(esd == null)
{
throw new ArgumentNullException("esd");
}
if(esd.Attribute("version") != "1")
{
throw new ArgumentException(_("Arg_PermissionVersion"));
}
value = esd.Attribute("Unrestricted");
if(value != null && Boolean.Parse(value))
{
window = UIPermissionWindow.NoWindows;
clipboard = UIPermissionClipboard.NoClipboard;
}
else
{
value = esd.Attribute("Window");
if(value != null)
{
window = (UIPermissionWindow)
Enum.Parse(typeof(UIPermissionWindow), value);
}
else
{
window = UIPermissionWindow.NoWindows;
}
value = esd.Attribute("Clipboard");
if(value != null)
{
clipboard = (UIPermissionClipboard)
Enum.Parse(typeof(UIPermissionClipboard), value);
}
else
{
clipboard = UIPermissionClipboard.NoClipboard;
}
}
}
/// <summary>Initializes a new instance of the <see cref="T:System.Security.Permissions.UIPermission" /> class with the permissions for windows, and no access to the Clipboard.</summary><param name="windowFlag">One of the enumeration values. </param><exception cref="T:System.ArgumentException">The <paramref name="windowFlag" /> parameter is not a valid <see cref="T:System.Security.Permissions.UIPermissionWindow" /> value. </exception>
public UIPermission(UIPermissionWindow windowFlag)
{
throw new NotImplementedException();
}
public UIPermission(UIPermissionWindow windowFlag )
{
VerifyWindowFlag( windowFlag );
m_windowFlag = windowFlag;
}
private void Reset()
{
m_windowFlag = UIPermissionWindow.NoWindows;
m_clipboardFlag = UIPermissionClipboard.NoClipboard;
}
public UIPermission (UIPermissionWindow windowFlag) {
return default(UIPermission);
}
public UIPermission (UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag) {
return default(UIPermission);
}
//------------------------------------------------------
//
// PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
//
//------------------------------------------------------
private static void VerifyWindowFlag(UIPermissionWindow flag)
{
if (flag < UIPermissionWindow.NoWindows || flag > UIPermissionWindow.AllWindows)
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)flag));
}
}
public override void FromXml (SecurityElement esd)
{
// General validation in CodeAccessPermission
CheckSecurityElement (esd, "esd", version, version);
// Note: we do not (yet) care about the return value
// as we only accept version 1 (min/max values)
if (IsUnrestricted (esd)) {
_window = UIPermissionWindow.AllWindows;
_clipboard = UIPermissionClipboard.AllClipboard;
}
else {
string w = esd.Attribute ("Window");
if (w == null)
_window = UIPermissionWindow.NoWindows;
else
_window = (UIPermissionWindow) Enum.Parse (typeof (UIPermissionWindow), w);
string c = esd.Attribute ("Clipboard");
if (c == null)
_clipboard = UIPermissionClipboard.NoClipboard;
else
_clipboard = (UIPermissionClipboard) Enum.Parse (typeof (UIPermissionClipboard), c);
}
}
// helpers
private bool IsEmpty (UIPermissionWindow w, UIPermissionClipboard c)
{
return ((w == UIPermissionWindow.NoWindows) && (c == UIPermissionClipboard.NoClipboard));
}
private static void VerifyWindowFlag(UIPermissionWindow flag)
{
if ((flag < UIPermissionWindow.NoWindows) || (flag > UIPermissionWindow.AllWindows))
{
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[] { (int) flag }));
}
}
private void Reset()
{
m_windowFlag = UIPermissionWindow.NoWindows;
m_clipboardFlag = UIPermissionClipboard.NoClipboard;
}
private void SetUnrestricted( bool unrestricted )
{
if (unrestricted)
{
m_windowFlag = UIPermissionWindow.AllWindows;
m_clipboardFlag = UIPermissionClipboard.AllClipboard;
}
}
public UIPermission (UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag)
{
// reuse validation by the Clipboard and Window properties
Clipboard = clipboardFlag;
Window = windowFlag;
}
public UIPermission(UIPermissionWindow windowFlag)
{
VerifyWindowFlag(windowFlag);
m_windowFlag = windowFlag;
}
public UIPermission (UIPermissionWindow windowFlag)
{
// reuse validation by the Window property
Window = windowFlag;
}
