2008-09-04 Jb Evain <jbevain@novell.com>

[mono.git] / mcs / class / System.Web / System.Web.UI / TemplateControl.jvm.cs

diff --git a/mcs/class/System.Web/System.Web.UI/TemplateControl.jvm.cs b/mcs/class/System.Web/System.Web.UI/TemplateControl.jvm.cs
index 6b3d588553cfc6005b89bc48e4f5c41108641aee..ebf72131e58a9a954d452e55a5a6146dbad70693 100644 (file)
--- a/mcs/class/System.Web/System.Web.UI/TemplateControl.jvm.cs
+++ b/mcs/class/System.Web/System.Web.UI/TemplateControl.jvm.cs
@@ -33,6 +33,7 @@ using System.Web.J2EE;
 using System.Xml;
 using vmw.common;
 using System.Web.Util;
+using System.Collections.Generic;
 
 namespace System.Web.UI {
 
@@ -60,6 +61,7 @@ namespace System.Web.UI {
                                                 "Page_CommitTransaction" };
 
                static readonly object [] EventKeys = {
+                                                Control.InitEvent,
 #if NET_2_0
                                                 Page.PreInitEvent,
                                                 Page.PreLoadEvent,
@@ -78,6 +80,27 @@ namespace System.Web.UI {
                                                commitTransaction
                };
 
+               enum LifeCycleEvent
+               {
+                       Init,
+#if NET_2_0
+                       PreInit,
+                       PreLoad,
+                       LoadComplete,
+                       PreRenderComplete,
+                       SaveStateComplete,
+                       InitComplete,
+#endif
+                       Load,
+                       DataBinding,
+                       PreRender,
+                       Disposed,
+                       Unload,
+                       Error,
+                       AbortTransaction,
+                       CommitTransaction
+               }
+
                const BindingFlags bflags = BindingFlags.Public |
                                                BindingFlags.NonPublic |
                                                BindingFlags.Instance;
@@ -179,14 +202,14 @@ namespace System.Web.UI {
 
                sealed class EventMethodMap
                {
-                       public EventMethodMap (object EventKey, MethodInfo Method, bool NoParameters)
+                       public EventMethodMap (LifeCycleEvent EventKeyIndex, MethodInfo Method, bool NoParameters)
                        {
-                               this.EventKey = EventKey;
+                               this.EventKeyIndex = EventKeyIndex;
                                this.Method = Method;
                                this.NoParameters = NoParameters;
                        }
 
-                       public readonly object EventKey;
+                       public readonly LifeCycleEvent EventKeyIndex;
                        public readonly MethodInfo Method;
                        public readonly bool NoParameters;
                }
@@ -217,7 +240,24 @@ namespace System.Web.UI {
                                typeof (object),
                                typeof (EventArgs) };
 
+                LifeCycleEvent[] _pageEvents = new LifeCycleEvent[] { 
+                    LifeCycleEvent.PreInit,
+                    LifeCycleEvent.PreLoad,
+                    LifeCycleEvent.LoadComplete,
+                    LifeCycleEvent.PreRenderComplete,
+                    LifeCycleEvent.SaveStateComplete,
+                    LifeCycleEvent.InitComplete
+                };
+                List<LifeCycleEvent> pageEvents = new List<LifeCycleEvent>(_pageEvents);
+
+                bool isPage = Page.GetType().IsAssignableFrom(GetType());
+
                                for (int i = 0; i < methodNames.Length; i++) {
+                    
+                    // Don't look for page-only events in non-page controls.
+                    if (!isPage && pageEvents.Contains((LifeCycleEvent)i))
+                        continue;
+
                                        string methodName = methodNames [i];
                                        MethodInfo method;
                                        bool noParams = false;
@@ -251,7 +291,7 @@ namespace System.Web.UI {
                                        if (method.ReturnType != voidType)
                                                continue;
 
-                                       eventMethodList.Add (new EventMethodMap (EventKeys [i], method, noParams));
+                                       eventMethodList.Add (new EventMethodMap ((LifeCycleEvent) i, method, noParams));
                                }
                                // We copy to not lock
 
@@ -261,14 +301,64 @@ namespace System.Web.UI {
                        }
 
                        foreach (EventMethodMap eventMethod in eventMethodList) {
-                               if (Events [eventMethod.EventKey] != null)
+                               EventHandler handler = eventMethod.NoParameters ?
+                                       new NoParamsInvoker (this, eventMethod.Method).FakeDelegate :
+                                       (EventHandler)Delegate.CreateDelegate (typeof (EventHandler), this, eventMethod.Method);
+
+                               object eventKey = EventKeys [(int) eventMethod.EventKeyIndex];
+
+                               Delegate existing = Events [eventKey];
+                               if (existing != null && handler.Equals(existing))
                                        continue;
-                               if (eventMethod.NoParameters) {
-                                       NoParamsInvoker npi = new NoParamsInvoker (this, eventMethod.Method);
-                                       Events.AddHandler (eventMethod.EventKey, npi.FakeDelegate);
-                               }
-                               else {
-                                       Events.AddHandler (eventMethod.EventKey, Delegate.CreateDelegate (typeof (EventHandler), this, eventMethod.Method));
+
+                               switch (eventMethod.EventKeyIndex) {
+                               case LifeCycleEvent.Init:
+                                       Init += handler;
+                                       break;
+#if NET_2_0
+                               case LifeCycleEvent.PreInit:
+                                       ((Page)this).PreInit += handler;
+                                       break;
+                               case LifeCycleEvent.PreLoad:
+                                       ((Page) this).PreLoad += handler;
+                                       break;
+                               case LifeCycleEvent.LoadComplete:
+                                       ((Page) this).LoadComplete += handler;
+                                       break;
+                               case LifeCycleEvent.PreRenderComplete:
+                                       ((Page) this).PreRenderComplete += handler;
+                                       break;
+                               case LifeCycleEvent.SaveStateComplete:
+                                       ((Page) this).SaveStateComplete += handler;
+                                       break;
+                               case LifeCycleEvent.InitComplete:
+                                       ((Page) this).InitComplete += handler;
+                                       break;
+#endif
+                               case LifeCycleEvent.Load:
+                                       Load += handler;
+                                       break;
+                               case LifeCycleEvent.DataBinding:
+                                       DataBinding += handler;
+                                       break;
+                               case LifeCycleEvent.PreRender:
+                                       PreRender += handler;
+                                       break;
+                               case LifeCycleEvent.Disposed:
+                                       Disposed += handler;
+                                       break;
+                               case LifeCycleEvent.Unload:
+                                       Unload += handler;
+                                       break;
+                               case LifeCycleEvent.Error:
+                                       Error += handler;
+                                       break;
+                               case LifeCycleEvent.AbortTransaction:
+                                       AbortTransaction += handler;
+                                       break;
+                               case LifeCycleEvent.CommitTransaction:
+                                       CommitTransaction += handler;
+                                       break;
                                }
                        }
                }