mcs/class/System.Web/System.Web.UI/TemplateControl.cs

   1 //
   2 // System.Web.UI.TemplateControl.cs
   3 //
   4 // Authors:
   5 //   Duncan Mak  (duncan@ximian.com)
   6 //   Gonzalo Paniagua Javier (gonzalo@ximian.com)
   7 //   Andreas Nahr (ClassDevelopment@A-SoftTech.com)
   8 //
   9 // (C) 2002 Ximian, Inc. (http://www.ximian.com)
  10 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System.Collections;
  33 using System.ComponentModel;
  34 using System.Reflection;
  35 using System.Security.Permissions;
  36 using System.Web.Compilation;
  37 using System.Web.Util;
  38 using System.Xml;
  39
  40 namespace System.Web.UI {
  41
  42         // CAS
  43         [AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  44         [AspNetHostingPermission (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  45 #if NET_2_0
  46         public abstract class TemplateControl : Control, INamingContainer, IFilterResolutionService {
  47 #else
  48         public abstract class TemplateControl : Control, INamingContainer {
  49 #endif
  50                 static readonly Assembly _System_Web_Assembly = typeof (TemplateControl).Assembly;
  51                 static object abortTransaction = new object ();
  52                 static object commitTransaction = new object ();
  53                 static object error = new object ();
  54                 static string [] methodNames = { "Page_Init",
  55 #if NET_2_0
  56                                                  "Page_PreInit",
  57                                                  "Page_PreLoad",
  58                                                  "Page_LoadComplete",
  59                                                  "Page_PreRenderComplete",
  60                                                  "Page_SaveStateComplete",
  61                                                  "Page_InitComplete",
  62 #endif
  63                                                  "Page_Load",
  64                                                  "Page_DataBind",
  65                                                  "Page_PreRender",
  66                                                  "Page_Disposed",
  67                                                  "Page_Error",
  68                                                  "Page_Unload",
  69                                                  "Page_AbortTransaction",
  70                                                  "Page_CommitTransaction"};
  71
  72                 const BindingFlags bflags = BindingFlags.Public |
  73                                             BindingFlags.NonPublic |
  74                                             BindingFlags.Instance;
  75
  76 #if NET_2_0
  77                 string _appRelativeVirtualPath;
  78 #endif
  79
  80                 #region Constructor
  81                 protected TemplateControl ()
  82                 {
  83                         Construct ();
  84                 }
  85
  86                 #endregion
  87
  88                 #region Properties
  89                 [EditorBrowsable (EditorBrowsableState.Never)]
  90 #if NET_2_0
  91                 [Obsolete]
  92 #endif
  93                 protected virtual int AutoHandlers {
  94                         get { return 0; }
  95                         set { }
  96                 }
  97
  98                 [EditorBrowsable (EditorBrowsableState.Never)]
  99                 protected virtual bool SupportAutoEvents {
 100                         get { return true; }
 101                 }
 102
 103 #if NET_2_0
 104                 public string AppRelativeVirtualPath {
 105                         get { return _appRelativeVirtualPath; }
 106                         set { _appRelativeVirtualPath = value; }
 107                 }
 108 #endif
 109
 110                 #endregion
 111
 112                 #region Methods
 113
 114                 protected virtual void Construct ()
 115                 {
 116                 }
 117
 118                 [MonoTODO ("Not implemented")]
 119                 protected LiteralControl CreateResourceBasedLiteralControl (int offset,
 120                                                                                     int size,
 121                                                                                     bool fAsciiOnly)
 122                 {
 123                         return null;
 124                 }
 125
 126                 internal void WireupAutomaticEvents ()
 127                 {
 128                         if (!SupportAutoEvents || !AutoEventWireup)
 129                                 return;
 130
 131                         foreach (string methodName in methodNames) {
 132                                 MethodInfo method = null;
 133                                 Type type;
 134                                 for (type = GetType (); type.Assembly != _System_Web_Assembly; type = type.BaseType) {
 135                                         method = type.GetMethod (methodName, bflags);
 136                                         if (method != null)
 137                                                 break;
 138                                 }
 139                                 if (method == null)
 140                                         continue;
 141
 142                                 if (method.DeclaringType != type) {
 143                                         if (!method.IsPublic && !method.IsFamilyOrAssembly &&
 144                                             !method.IsFamilyAndAssembly && !method.IsFamily)
 145                                                 continue;
 146                                 }
 147
 148                                 if (method.ReturnType != typeof (void))
 149                                         continue;
 150
 151                                 ParameterInfo [] parms = method.GetParameters ();
 152                                 int length = parms.Length;
 153                                 bool noParams = (length == 0);
 154                                 if (!noParams && (length != 2 ||
 155                                     parms [0].ParameterType != typeof (object) ||
 156                                     parms [1].ParameterType != typeof (EventArgs)))
 157                                     continue;
 158
 159                                 int pos = methodName.IndexOf ("_");
 160                                 string eventName = methodName.Substring (pos + 1);
 161                                 EventInfo evt = type.GetEvent (eventName);
 162                                 if (evt == null) {
 163                                         /* This should never happen */
 164                                         continue;
 165                                 }
 166
 167                                 if (noParams) {
 168                                         NoParamsInvoker npi = new NoParamsInvoker (this, method);
 169                                         evt.AddEventHandler (this, npi.FakeDelegate);
 170                                 } else {
 171                                         evt.AddEventHandler (this, Delegate.CreateDelegate (
 172 #if NET_2_0
 173                                                         typeof (EventHandler), this, method));
 174 #else
 175                                                         typeof (EventHandler), this, methodName));
 176 #endif
 177                                 }
 178                         }
 179                 }
 180
 181                 [EditorBrowsable (EditorBrowsableState.Never)]
 182                 protected virtual void FrameworkInitialize ()
 183                 {
 184                 }
 185
 186                 Type GetTypeFromControlPath (string virtualPath)
 187                 {
 188                         if (virtualPath == null)
 189                                 throw new ArgumentNullException ("virtualPath");
 190
 191                         string vpath = UrlUtils.Combine (TemplateSourceDirectory, virtualPath);
 192                         string realpath = Context.Request.MapPath (vpath);
 193                         return UserControlParser.GetCompiledType (vpath, realpath, Context);
 194                 }
 195
 196                 public Control LoadControl (string virtualPath)
 197                 {
 198 #if NET_2_0
 199                         if (virtualPath == null)
 200                                 throw new ArgumentNullException ("virtualPath");
 201 #else
 202                         if (virtualPath == null)
 203                                 throw new HttpException ("virtualPath is null");
 204 #endif
 205                         Type type = GetTypeFromControlPath (virtualPath);
 206                         object [] attrs = type.GetCustomAttributes (typeof (PartialCachingAttribute), true);
 207                         if (attrs != null && attrs.Length == 1) {
 208                                 PartialCachingAttribute attr = (PartialCachingAttribute) attrs [0];
 209                                 PartialCachingControl ctrl = new PartialCachingControl (type);
 210                                 ctrl.VaryByParams = attr.VaryByParams;
 211                                 ctrl.VaryByControls = attr.VaryByControls;
 212                                 ctrl.VaryByCustom = attr.VaryByCustom;
 213                                 return ctrl;
 214                         }
 215
 216                         object control = Activator.CreateInstance (type);
 217                         if (control is UserControl)
 218                                 ((UserControl) control).InitializeAsUserControl (Page);
 219
 220                         return (Control) control;
 221                 }
 222
 223                 public ITemplate LoadTemplate (string virtualPath)
 224                 {
 225 #if NET_2_0
 226                         if (virtualPath == null)
 227                                 throw new ArgumentNullException ("virtualPath");
 228 #else
 229                         if (virtualPath == null)
 230                                 throw new HttpException ("virtualPath is null");
 231 #endif
 232                         Type t = GetTypeFromControlPath (virtualPath);
 233                         return new SimpleTemplate (t);
 234                 }
 235
 236                 protected virtual void OnAbortTransaction (EventArgs e)
 237                 {
 238                         EventHandler eh = Events [abortTransaction] as EventHandler;
 239                         if (eh != null)
 240                                 eh (this, e);
 241                 }
 242
 243                 protected virtual void OnCommitTransaction (EventArgs e)
 244                 {
 245                         EventHandler eh = Events [commitTransaction] as EventHandler;
 246                         if (eh != null)
 247                                 eh (this, e);
 248                 }
 249
 250                 protected virtual void OnError (EventArgs e)
 251                 {
 252                         EventHandler eh = Events [error] as EventHandler;
 253                         if (eh != null)
 254                                 eh (this, e);
 255                 }
 256
 257                 [MonoTODO ("Not implemented, always returns null")]
 258                 public Control ParseControl (string content)
 259                 {
 260                         if (content == null)
 261                                 throw new ArgumentNullException ("content");
 262
 263                         return null;
 264                 }
 265
 266                 [EditorBrowsable (EditorBrowsableState.Never)]
 267                 public
 268 #if !NET_2_0
 269                 static
 270 #endif
 271                 object ReadStringResource ()
 272                 {
 273                         throw new NotSupportedException ();
 274                 }
 275
 276 #if NET_2_0
 277                 protected object GetGlobalResourceObject (string className, string resourceKey)
 278                 {
 279                         return HttpContext.GetGlobalResourceObject (className, resourceKey);
 280                 }
 281
 282                 [MonoTODO ("Not implemented")]
 283                 protected object GetGlobalResourceObject (string className, string resourceKey, Type objType, string propName)
 284                 {
 285                         // FIXME: not sure how to implement that one yet
 286                         throw new NotSupportedException();
 287                 }
 288
 289                 protected object GetLocalResourceObject (string resourceKey)
 290                 {
 291                         return HttpContext.GetLocalResourceObject (VirtualPathUtility.ToAbsolute (this.AppRelativeVirtualPath),
 292                                                                    resourceKey);
 293                 }
 294
 295                 protected object GetLocalResourceObject (string resourceKey, Type objType, string propName)
 296                 {
 297                         // FIXME: not sure how to implement that one yet
 298                         throw new NotSupportedException();
 299                 }
 300 #endif
 301
 302                 [EditorBrowsable (EditorBrowsableState.Never)]
 303                 public static object ReadStringResource (Type t)
 304                 {
 305                         throw new NotSupportedException ();
 306                 }
 307
 308                 [MonoTODO ("Not implemented, does nothing")]
 309                 [EditorBrowsable (EditorBrowsableState.Never)]
 310                 protected void SetStringResourcePointer (object stringResourcePointer,
 311                                                          int maxResourceOffset)
 312                 {
 313                 }
 314
 315                 [MonoTODO ("Not implemented, does nothing")]
 316                 [EditorBrowsable (EditorBrowsableState.Never)]
 317                 protected void WriteUTF8ResourceString (HtmlTextWriter output, int offset,
 318                                                         int size, bool fAsciiOnly)
 319                 {
 320                 }
 321
 322                 #endregion
 323
 324                 #region Events
 325
 326                 [WebSysDescription ("Raised when the user aborts a transaction.")]
 327                 public event EventHandler AbortTransaction {
 328                         add { Events.AddHandler (abortTransaction, value); }
 329                         remove { Events.RemoveHandler (abortTransaction, value); }
 330                 }
 331
 332                 [WebSysDescription ("Raised when the user initiates a transaction.")]
 333                 public event EventHandler CommitTransaction {
 334                         add { Events.AddHandler (commitTransaction, value); }
 335                         remove { Events.RemoveHandler (commitTransaction, value); }
 336                 }
 337
 338                 [WebSysDescription ("Raised when an exception occurs that cannot be handled.")]
 339                 public event EventHandler Error {
 340                         add { Events.AddHandler (error, value); }
 341                         remove { Events.RemoveHandler (error, value); }
 342                 }
 343
 344                 #endregion
 345
 346                 class SimpleTemplate : ITemplate
 347                 {
 348                         Type type;
 349
 350                         public SimpleTemplate (Type type)
 351                         {
 352                                 this.type = type;
 353                         }
 354
 355                         public void InstantiateIn (Control control)
 356                         {
 357                                 Control template = Activator.CreateInstance (type) as Control;
 358                                 template.SetBindingContainer (false);
 359                                 control.Controls.Add (template);
 360                         }
 361                 }
 362
 363 #if NET_2_0
 364                 protected internal object Eval (string expression)
 365                 {
 366                         return DataBinder.Eval (Page.GetDataItem(), expression);
 367                 }
 368
 369                 protected internal string Eval (string expression, string format)
 370                 {
 371                         return DataBinder.Eval (Page.GetDataItem(), expression, format);
 372                 }
 373
 374                 protected internal object XPath (string xpathexpression)
 375                 {
 376                         return XPathBinder.Eval (Page.GetDataItem(), xpathexpression);
 377                 }
 378
 379                 protected internal object XPath (string xpathexpression, IXmlNamespaceResolver resolver)
 380                 {
 381                         return XPathBinder.Eval (Page.GetDataItem (), xpathexpression, null, resolver);
 382                 }
 383
 384                 protected internal string XPath (string xpathexpression, string format)
 385                 {
 386                         return XPathBinder.Eval (Page.GetDataItem(), xpathexpression, format);
 387                 }
 388
 389                 protected internal string XPath (string xpathexpression, string format, IXmlNamespaceResolver resolver)
 390                 {
 391                         return XPathBinder.Eval (Page.GetDataItem (), xpathexpression, format, resolver);
 392                 }
 393
 394                 protected internal IEnumerable XPathSelect (string xpathexpression)
 395                 {
 396                         return XPathBinder.Select (Page.GetDataItem(), xpathexpression);
 397                 }
 398
 399                 protected internal IEnumerable XPathSelect (string xpathexpression, IXmlNamespaceResolver resolver)
 400                 {
 401                         return XPathBinder.Select (Page.GetDataItem (), xpathexpression, resolver);
 402                 }
 403
 404                 // IFilterResolutionService
 405
 406                 [MonoTODO ("Not implemented")]
 407                 int IFilterResolutionService.CompareFilters (string filter1, string filter2)
 408                 {
 409                         throw new NotImplementedException ();
 410                 }
 411
 412                 [MonoTODO ("Not implemented")]
 413                 bool IFilterResolutionService.EvaluateFilter (string filterName)
 414                 {
 415                         throw new NotImplementedException ();
 416                 }
 417 #endif
 418         }
 419 }