D:/Projects/Anthem/Anthem/RadioButtonList.cs

using System;
using System.ComponentModel;
using System.Drawing;
using System.IO;
using System.Text.RegularExpressions;
using System.Web;
using System.Web.UI;
using ASP = System.Web.UI.WebControls;

namespace Anthem
{
    [ToolboxBitmap(typeof(ASP.RadioButtonList))]
    public class RadioButtonList : ASP.RadioButtonList, IUpdatableControl, ICallBackControl
    {
        #region Unique Anthem control code

        [DefaultValue(false)]
        public bool AutoCallBack
        {
            get
            {
                if (null == ViewState["AutoCallBack"])
                    return false;
                else
                    return (bool)ViewState["AutoCallBack"];
            }
            set { ViewState["AutoCallBack"] = value; }
        }

#if V2
        [Category("Default")]
        [DefaultValue("")]
        [MergableProperty(false)]
        [PersistenceMode(PersistenceMode.InnerProperty)]
        public override ASP.ListItemCollection Items
        {
            get
            {
                return base.Items;
            }
        }
#endif

#if V2
        protected override void OnSelectedIndexChanged(EventArgs e)
        {
            base.OnSelectedIndexChanged(e);
            this.UpdateAfterCallBack = true;
        }

        private int _renderedItemIndex = 0;
        protected override void RenderItem(ASP.ListItemType itemType, int repeatIndex, ASP.RepeatInfo repeatInfo, HtmlTextWriter writer)
        {
            if (AutoCallBack)
            {
                ASP.ListItem item = this.Items[_renderedItemIndex];
                if (item.Selected)
                {
                    item.Attributes.Remove("onclick");
                }
                else
                {
                    item.Attributes["onclick"] = Anthem.Manager.GetCallbackEventReference(
                        this,
                        _renderedItemIndex.ToString(),
                        this.CausesValidation,
                        this.ValidationGroup
                    );
                }
                _renderedItemIndex += 1;
            }

            base.RenderItem(itemType, repeatIndex, repeatInfo, writer);
        }
#else
        // The ASP.NET 1.1 version of RadioButtonList does not have an override for creating each
        // item in the list, so we need some to use some method that takes affect on the entire
        // control. One option is to let the base control render to a string and then use Regex
        // to replace __doPostBack with Anthem_FireCallBackEvent. That is how the Calendar
        // control is handled. However, that technique is "fragile" because it will not work
        // if the base control changes how it is rendered (such as a change in HtmlWriter).
        // During my testing, I noticed that ASP.NET 1.1 always rendered the __doPostBack for
        // each item, even if it was already selected. I decided to take advantage of this
        // and also the fact that javascript events bubble up to the parent element. So this
        // override of OnPreRender adds a single Anthem callback to the parent element.
        protected override void OnPreRender(EventArgs e)
        {
            base.OnPreRender(e);
            if (AutoCallBack)
            {
                Anthem.Manager.AddScriptAttribute(
                    this,
                    "onclick",
                    string.Format(
                    "AnthemListControl_OnClick(event,{0},'{1}','{2}',{3},{4},{5},{6});",
                    "false",
                    string.Empty,
                    this.TextDuringCallBack,
                    this.EnabledDuringCallBack ? "true" : "false",
                    (this.PreCallBackFunction == null || this.PreCallBackFunction.Length == 0) ? "null" : this.PreCallBackFunction,
                    (this.PostCallBackFunction == null || this.PostCallBackFunction.Length == 0) ? "null" : this.PostCallBackFunction,
                    (this.CallBackCancelledFunction == null || this.CallBackCancelledFunction.Length == 0) ? "null" : this.CallBackCancelledFunction
                    )
                );
            }
        }
#endif

        protected override void Render(HtmlTextWriter writer)
        {
#if !V2
            bool DesignMode = this.Context == null;
#endif
            if (!DesignMode)
            {
                Anthem.Manager.WriteBeginControlMarker(writer, this.RepeatLayout == ASP.RepeatLayout.Flow ? "span" : "div", this);
            }
            if (Visible)
            {
                base.Render(writer);
            }
            if (!DesignMode)
            {
                Anthem.Manager.WriteEndControlMarker(writer, this.RepeatLayout == ASP.RepeatLayout.Flow ? "span" : "div", this);
            }
        }

        #endregion

        #region ICallBackControl implementation

        [Category("Anthem")]
        [DefaultValue("")]
        [Description("The javascript function to call on the client if the callback is cancelled.")]
        public virtual string CallBackCancelledFunction
        {
            get
            {
                string text = (string)ViewState["CallBackCancelledFunction"];
                if (text == null)
                    return string.Empty;
                else
                    return text;
            }
            set
            {
                ViewState["CallBackCancelledFunction"] = value;
            }
        }

        [Category("Anthem")]
        [DefaultValue(true)]
        [Description("True if this control uses callbacks instead of postbacks to post data to the server.")]
        public virtual bool EnableCallBack
        {
            get
            {
                object obj = this.ViewState["EnableCallBack"];
                if (obj == null)
                    return true;
                else
                    return (bool)obj;
            }
            set
            {
                ViewState["EnableCallBack"] = value;
            }
        }

        [Category("Anthem")]
        [DefaultValue(true)]
        [Description("True if this control is enabled on the client during callbacks.")]
        public virtual bool EnabledDuringCallBack
        {
            get
            {
                object obj = this.ViewState["EnabledDuringCallBack"];
                if (obj == null)
                    return true;
                else
                    return (bool)obj;
            }
            set
            {
                ViewState["EnabledDuringCallBack"] = value;
            }
        }


        [Category("Anthem")]
        [DefaultValue("")]
        [Description("The javascript function to call on the client after the callback response is received.")]
        public virtual string PostCallBackFunction
        {
            get
            {
                string text = (string)this.ViewState["PostCallBackFunction"];
                if (text == null)
                {
                    return string.Empty;
                }
                return text;
            }
            set
            {
                ViewState["PostCallBackFunction"] = value;
            }
        }

        [Category("Anthem")]
        [DefaultValue("")]
        [Description("The javascript function to call on the client before the callback is made.")]
        public virtual string PreCallBackFunction
        {
            get
            {
                string text = (string)this.ViewState["PreCallBackFunction"];
                if (text == null)
                {
                    return string.Empty;
                }
                return text;
            }
            set
            {
                ViewState["PreCallBackFunction"] = value;
            }
        }

        [Category("Anthem")]
        [DefaultValue("")]
        [Description("The text to display during the callback.")]
        public virtual string TextDuringCallBack
        {
            get
            {
                string text = (string)this.ViewState["TextDuringCallBack"];
                if (text == null)
                {
                    return string.Empty;
                }
                return text;
            }
            set
            {
                ViewState["TextDuringCallBack"] = value;
            }
        }

        #endregion

        #region IUpdatableControl implementation

        [Category("Anthem")]
        [DefaultValue(false)]
        [Description("True if this control should be updated after each callback.")]
        public virtual bool AutoUpdateAfterCallBack
        {
            get
            {
                object obj = this.ViewState["AutoUpdateAfterCallBack"];
                if (obj == null)
                    return false;
                else
                    return (bool)obj;
            }
            set
            {
                if (value) UpdateAfterCallBack = true;
                ViewState["AutoUpdateAfterCallBack"] = value;
            }
        }

        private bool _updateAfterCallBack = false;

        [Browsable(false)]
        [DefaultValue(false)]
        public virtual bool UpdateAfterCallBack
        {
            get { return _updateAfterCallBack; }
            set { _updateAfterCallBack = value; }
        }

        #endregion

        #region Common Anthem control code

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            Anthem.Manager.Register(this);
        }

#if V2
        public override void RenderControl(HtmlTextWriter writer)
        {
            base.Visible = true;
            base.RenderControl(writer);
        }
#endif

        public override bool Visible
        {
            get
            {
#if !V2
                bool DesignMode = this.Context == null;
#endif
                return Anthem.Manager.GetControlVisible(this, ViewState, DesignMode);
            }
            set { Anthem.Manager.SetControlVisible(ViewState, value); }
        }

        #endregion
    }
}

---