mcs/class/corlib/System.Security.Permissions/FileDialogPermission.cs

   1 //
   2 // System.Security.Permissions.FileDialogPermission.cs
   3 //
   4 // Author
   5 //      Sebastien Pouliot  <spouliot@motus.com>
   6 //
   7 // Copyright (C) 2003 Motus Technologies. http://www.motus.com
   8 //
   9
  10 using System;
  11
  12 namespace System.Security.Permissions {
  13
  14         [Serializable]
  15         public sealed class FileDialogPermission : CodeAccessPermission, IUnrestrictedPermission {
  16
  17                 private FileDialogPermissionAccess _access;
  18
  19                 // Constructors
  20
  21                 public FileDialogPermission (PermissionState state)
  22                 {
  23                         switch (state) {
  24                                 case PermissionState.None:
  25                                         _access = FileDialogPermissionAccess.None;
  26                                         break;
  27                                 case PermissionState.Unrestricted:
  28                                         _access = FileDialogPermissionAccess.OpenSave;
  29                                         break;
  30                                 default:
  31                                         throw new ArgumentException ("Invalid PermissionState", "state");
  32                         }
  33                 }
  34
  35                 public FileDialogPermission (FileDialogPermissionAccess access)
  36                 {
  37                         Access = access;
  38                 }
  39
  40                 // Properties
  41
  42                 public FileDialogPermissionAccess Access {
  43                         get { return _access; }
  44                         set {
  45                                 switch (value) {
  46                                         case FileDialogPermissionAccess.None:
  47                                         case FileDialogPermissionAccess.Open:
  48                                         case FileDialogPermissionAccess.Save:
  49                                         case FileDialogPermissionAccess.OpenSave:
  50                                                 _access = value;
  51                                                 break;
  52                                         default:
  53                                                 throw new ArgumentException ("Invalid FileDialogPermissionAccess", "access");
  54                                 }
  55                         }
  56                 }
  57
  58                 // Methods
  59
  60                 public override IPermission Copy ()
  61                 {
  62                         return new FileDialogPermission (_access);
  63                 }
  64
  65                 public override void FromXml (SecurityElement esd)
  66                 {
  67                         if (esd == null)
  68                                 throw new ArgumentNullException ("esd");
  69                         if (esd.Tag != "IPermission")
  70                                 throw new ArgumentException ("not IPermission");
  71                         if (!(esd.Attributes ["class"] as string).StartsWith ("System.Security.Permissions.FileDialogPermission"))
  72                                 throw new ArgumentException ("not FileDialogPermission");
  73                         if ((esd.Attributes ["version"] as string) != "1")
  74                                 throw new ArgumentException ("wrong version");
  75
  76                         switch (esd.Attributes ["Access"] as string) {
  77                                 case null:
  78                                         if ((esd.Attributes ["Unrestricted"] as string) == "true") {
  79                                                 _access = FileDialogPermissionAccess.OpenSave;
  80                                         }
  81                                         else
  82                                                 _access = FileDialogPermissionAccess.None;
  83                                         break;
  84                                 case "Open":
  85                                         _access = FileDialogPermissionAccess.Open;
  86                                         break;
  87                                 case "Save":
  88                                         _access = FileDialogPermissionAccess.Save;
  89                                         break;
  90                         }
  91                 }
  92
  93                 public override IPermission Intersect (IPermission target)
  94                 {
  95                         if (target == null)
  96                                 return null;
  97                         if (! (target is FileDialogPermission))
  98                                 throw new ArgumentException ("wrong type");
  99
 100                         FileDialogPermission o = (FileDialogPermission) target;
 101                         if (IsUnrestricted ())
 102                                 return o.Copy ();
 103                         if (o.IsUnrestricted ())
 104                                 return Copy ();
 105
 106                         FileDialogPermission ep = new FileDialogPermission (PermissionState.None);
 107                         // note: there are no more OpenSave cases (as they're Unrestricted)
 108                         if ((_access == FileDialogPermissionAccess.Open) && (o.Access == FileDialogPermissionAccess.Open))
 109                                 ep.Access = FileDialogPermissionAccess.Open;
 110                         if ((_access == FileDialogPermissionAccess.Save) && (o.Access == FileDialogPermissionAccess.Save))
 111                                 ep.Access = FileDialogPermissionAccess.Save;
 112                         return ((ep.Access == FileDialogPermissionAccess.None) ? null : ep);
 113                 }
 114
 115                 public override bool IsSubsetOf (IPermission target)
 116                 {
 117                         if (target == null)
 118                                 return false;
 119
 120                         if (! (target is FileDialogPermission))
 121                                 throw new ArgumentException ("wrong type");
 122
 123                         FileDialogPermission o = (FileDialogPermission) target;
 124                         if (IsUnrestricted ())
 125                                 return o.IsUnrestricted ();
 126                         else if (o.IsUnrestricted ())
 127                                 return true;
 128
 129                         return ((_access | o.Access) == _access);
 130                 }
 131
 132                 public bool IsUnrestricted ()
 133                 {
 134                         return (_access == FileDialogPermissionAccess.OpenSave);
 135                 }
 136
 137                 // Same results as base class - so why is it overrided ?
 138                 public override string ToString ()
 139                 {
 140                         return base.ToString ();
 141                 }
 142
 143                 public override SecurityElement ToXml ()
 144                 {
 145                         SecurityElement se = Element (this, 1);
 146                         switch (_access) {
 147                                 case FileDialogPermissionAccess.Open:
 148                                         se.AddAttribute ("Access", "Open");
 149                                         break;
 150                                 case FileDialogPermissionAccess.Save:
 151                                         se.AddAttribute ("Access", "Save");
 152                                         break;
 153                                 case FileDialogPermissionAccess.OpenSave:
 154                                         se.AddAttribute ("Unrestricted", "true");
 155                                         break;
 156                         }
 157                         return se;
 158                 }
 159
 160                 public override IPermission Union (IPermission target)
 161                 {
 162                         if (target == null)
 163                                 return Copy ();
 164                         if (! (target is FileDialogPermission))
 165                                 throw new ArgumentException ("wrong type");
 166
 167                         FileDialogPermission o = (FileDialogPermission) target;
 168                         if (IsUnrestricted () || o.IsUnrestricted ())
 169                                 return new FileDialogPermission (PermissionState.Unrestricted);
 170
 171                         FileDialogPermission ep = (FileDialogPermission) Copy ();
 172                         ep.Access = _access | o.Access;
 173                         return ep;
 174                 }
 175         }
 176 }