1.1 .net VS 2003

[DefaultProperty("Text"), Themeable(true), AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal), AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
public class ImageList : Control, IScriptControl
{
    // Fields
    private string _CssClass;
    private bool _Enabled = true;
    private Unit _Height;
    private string _ImageCssClass;
    private ImageListItemCollection _ImageListItemCollection;
    private string _ItemCssClass;
    private string _ItemHoverCssClass;
    private int _LinesOfText = 0;
    private string _RemoveCssClass;
    private string _RemoveImage;
    private string _RemoveTooltip;
    private string _TextCssClass;
    private Unit _Width;

    // Methods
    protected ImageListItemCollection DeserializeListItems(string stream)
    {
        if (string.IsNullOrEmpty(stream))
        {
            return new ImageListItemCollection();
        }
        JavaScriptSerializer serializer = new JavaScriptSerializer();
        return new ImageListItemCollection(serializer.Deserialize<ImageListItem[]>(stream));
    }

    protected virtual IEnumerable<ScriptDescriptor> GetScriptDescriptors()
    {
        d__3 d__ = new d__3(-2);
        d__.<>4__this = this;
        return d__;
    }

    protected virtual IEnumerable<ScriptReference> GetScriptReferences()
    {
        d__0 d__ = new d__0(-2);
        d__.<>4__this = this;
        return d__;
    }

    protected override void OnLoad(EventArgs e)
    {
        string str = this.ClientID + "_HiddenField";
        if (this.Page.Request.Form[str] != null)
        {
            string stream = this.Page.Request.Form[str];
            this._ImageListItemCollection = this.DeserializeListItems(stream);
        }
        base.OnLoad(e);
    }

    protected override void OnPreRender(EventArgs e)
    {
        if (!base.get_DesignMode())
        {
            ScriptManager current = ScriptManager.GetCurrent(this.Page);
            if (current == null)
            {
                throw new HttpException("A ScriptManager control must exist on the current page.");
            }
            current.RegisterScriptControl<ImageList>(this);
        }
        base.OnPreRender(e);
    }

    protected override void Render(HtmlTextWriter writer)
    {
        writer.AddAttribute(HtmlTextWriterAttribute.Id, this.ClientID);
        writer.AddStyleAttribute((HtmlTextWriterStyle) 0x1b, "auto");
        writer.AddStyleAttribute((HtmlTextWriterStyle) 0x23, "relative");
        if (!this._Width.IsEmpty)
        {
            writer.AddStyleAttribute(HtmlTextWriterStyle.Width, this._Width.ToString());
        }
        if (!this._Height.IsEmpty)
        {
            writer.AddStyleAttribute(HtmlTextWriterStyle.Height, this._Height.ToString());
        }
        if (!string.IsNullOrEmpty(this._CssClass))
        {
            writer.AddAttribute(HtmlTextWriterAttribute.Class, this._CssClass);
        }
        writer.RenderBeginTag(HtmlTextWriterTag.Div);
        writer.RenderEndTag();
        writer.AddAttribute(HtmlTextWriterAttribute.Id, this.ClientID + "_HiddenField");
        writer.AddAttribute(HtmlTextWriterAttribute.Name, this.ClientID + "_HiddenField");
        writer.AddAttribute(HtmlTextWriterAttribute.Type, "hidden");
        writer.AddAttribute(HtmlTextWriterAttribute.Value, this.SerializeListItems(this._ImageListItemCollection));
        writer.RenderBeginTag(HtmlTextWriterTag.Input);
        if (!base.get_DesignMode())
        {
            ScriptManager.GetCurrent(this.Page).RegisterScriptDescriptors(this);
        }
        base.Render(writer);
    }

    protected string SerializeListItems(ImageListItemCollection listItemCollection)
    {
        if ((listItemCollection == null) || (listItemCollection.Count < 1))
        {
            return string.Empty;
        }
        JavaScriptSerializer serializer = new JavaScriptSerializer();
        ImageListItem[] itemArray = listItemCollection.ToArray();
        return serializer.Serialize(itemArray);
    }

    IEnumerable<ScriptDescriptor> IScriptControl.GetScriptDescriptors()
    {
        return this.GetScriptDescriptors();
    }

    IEnumerable<ScriptReference> IScriptControl.GetScriptReferences()
    {
        return this.GetScriptReferences();
    }

    // Properties
    [DefaultValue(""), Category("Appearance"), Description("CSS class applied to the ImageList container div")]
    public string CssClass
    {
        get
        {
            return this._CssClass;
        }
        set
        {
            this._CssClass = value;
        }
    }

    [DefaultValue(true), Category("Appearance"), Description("Whether to enable/disable the mouseover/out and remove events")]
    public bool Enabled
    {
        get
        {
            return this._Enabled;
        }
        set
        {
            this._Enabled = value;
        }
    }

    [Browsable(true)]
    public override bool EnableTheming
    {
        get
        {
            return base.get_EnableTheming();
        }
        set
        {
            base.set_EnableTheming(value);
        }
    }

    [Description("Height of the ListItem control"), Category("Layout"), DefaultValue(typeof(Unit), "")]
    public Unit Height
    {
        get
        {
            return this._Height;
        }
        set
        {
            this._Height = value;
        }
    }

    [DefaultValue(""), Description("CSS class applied to an Item's image"), Category("Appearance")]
    public string ImageCssClass
    {
        get
        {
            return this._ImageCssClass;
        }
        set
        {
            this._ImageCssClass = value;
        }
    }

    [Themeable(false), Browsable(false)]
    public ImageListItemCollection ImageListItemCollection
    {
        get
        {
            if (this._ImageListItemCollection == null)
            {
                this._ImageListItemCollection = new ImageListItemCollection();
            }
            return this._ImageListItemCollection;
        }
    }

    [DefaultValue(""), Category("Appearance"), Description("CSS class applied to an Item div")]
    public string ItemCssClass
    {
        get
        {
            return this._ItemCssClass;
        }
        set
        {
            this._ItemCssClass = value;
        }
    }

    [DefaultValue(""), Category("Appearance"), Description("CSS class applied when hovering an Item div")]
    public string ItemHoverCssClass
    {
        get
        {
            return this._ItemHoverCssClass;
        }
        set
        {
            this._ItemHoverCssClass = value;
        }
    }

    [Category("Appearance"), DefaultValue(0), Description("CSS class applied to the remove icon")]
    public int LinesOfText
    {
        get
        {
            return this._LinesOfText;
        }
        set
        {
            this._LinesOfText = value;
        }
    }

    [Category("Appearance"), DefaultValue(""), Description("CSS class applied to the remove icon")]
    public string RemoveCssClass
    {
        get
        {
            return this._RemoveCssClass;
        }
        set
        {
            this._RemoveCssClass = value;
        }
    }

    [Description("Url for the remove image button"), Editor(typeof(UrlEditor), typeof(UITypeEditor)), Category("Appearance"), DefaultValue("")]
    public string RemoveImage
    {
        get
        {
            return this._RemoveImage;
        }
        set
        {
            this._RemoveImage = value;
        }
    }

    [Description("Tooltip for the remove image button"), Category("Appearance"), DefaultValue(""), Localizable(true), Themeable(false)]
    public string RemoveTooltip
    {
        get
        {
            return this._RemoveTooltip;
        }
        set
        {
            this._RemoveTooltip = value;
        }
    }

    [Browsable(true)]
    public override string SkinID
    {
        get
        {
            return base.get_SkinID();
        }
        set
        {
            base.set_SkinID(value);
        }
    }

    [DefaultValue(""), Category("Appearance"), Description("CSS class applied to an Item's text")]
    public string TextCssClass
    {
        get
        {
            return this._TextCssClass;
        }
        set
        {
            this._TextCssClass = value;
        }
    }

    [DefaultValue(typeof(Unit), ""), Category("Layout"), Description("Width of the ListItem control")]
    public Unit Width
    {
        get
        {
            return this._Width;
        }
        set
        {
            this._Width = value;
        }
    }

    // Nested Types
    [CompilerGenerated]
    private sealed class d__3 : IEnumerable<ScriptDescriptor>, IEnumerable, IEnumerator<ScriptDescriptor>, IEnumerator, IDisposable
    {
        // Fields
        private int <>1__state;
        private ScriptDescriptor <>2__current;
        public ImageList <>4__this;
        public ScriptControlDescriptor 5__4;
        public string 5__5;

        // Methods
        [DebuggerHidden]
        public d__3(int <>1__state)
        {
            this.<>1__state = <>1__state;
        }

        private bool MoveNext()
        {
            switch (this.<>1__state)
            {
                case 0:
                    this.<>1__state = -1;
                    this.5__4 = new ScriptControlDescriptor("Memba.WebControls.ImageList", this.<>4__this.ClientID);
                    this.5__4.AddProperty("removeTooltip", this.<>4__this.RemoveTooltip);
                    if (!string.IsNullOrEmpty(this.<>4__this.RemoveImage))
                    {
                        this.5__5 = this.<>4__this.ResolveClientUrl(this.<>4__this.RemoveImage);
                        break;
                    }
                    this.5__5 = this.<>4__this.Page.get_ClientScript().GetWebResourceUrl(typeof(ImageList), "Memba.WebControls.Styles.remove.gif");
                    break;

                case 1:
                    this.<>1__state = -1;
                    goto Label_01C5;

                default:
                    goto Label_01C5;
            }
            this.5__4.AddProperty("removeImage", this.5__5);
            this.5__4.AddProperty("cssClass", this.<>4__this.CssClass);
            this.5__4.AddProperty("itemCssClass", this.<>4__this.ItemCssClass);
            this.5__4.AddProperty("itemHoverCssClass", this.<>4__this.ItemHoverCssClass);
            this.5__4.AddProperty("imageCssClass", this.<>4__this.ImageCssClass);
            this.5__4.AddProperty("textCssClass", this.<>4__this.TextCssClass);
            this.5__4.AddProperty("removeCssClass", this.<>4__this.RemoveCssClass);
            this.5__4.AddProperty("linesOfText", this.<>4__this.LinesOfText);
            this.5__4.AddProperty("enabled", this.<>4__this.Enabled);
            this.<>2__current = this.5__4;
            this.<>1__state = 1;
            return true;
        Label_01C5:
            return false;
        }

        [DebuggerHidden]
        IEnumerator<ScriptDescriptor> IEnumerable<ScriptDescriptor>.GetEnumerator()
        {
            if (Interlocked.CompareExchange(ref this.<>1__state, 0, -2) == -2)
            {
                return this;
            }
            ImageList.d__3 d__ = new ImageList.d__3(0);
            d__.<>4__this = this.<>4__this;
            return d__;
        }

        [DebuggerHidden]
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.System.Collections.Generic.IEnumerable.GetEnumerator();
        }

        [DebuggerHidden]
        void IEnumerator.Reset()
        {
            throw new NotSupportedException();
        }

        void IDisposable.Dispose()
        {
        }

        // Properties
        ScriptDescriptor IEnumerator<ScriptDescriptor>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class d__0 : IEnumerable<ScriptReference>, IEnumerable, IEnumerator<ScriptReference>, IEnumerator, IDisposable
    {
        // Fields
        private int <>1__state;
        private ScriptReference <>2__current;
        public ImageList <>4__this;

        // Methods
        [DebuggerHidden]
        public d__0(int <>1__state)
        {
            this.<>1__state = <>1__state;
        }

        private bool MoveNext()
        {
            switch (this.<>1__state)
            {
                case 0:
                    this.<>1__state = -1;
                    this.<>2__current = new ScriptReference(this.<>4__this.Page.get_ClientScript().GetWebResourceUrl(this.<>4__this.GetType(), "Memba.WebControls.JavaScript.ImageList.js"));
                    this.<>1__state = 1;
                    return true;

                case 1:
                    this.<>1__state = -1;
                    break;
            }
            return false;
        }

        [DebuggerHidden]
        IEnumerator<ScriptReference> IEnumerable<ScriptReference>.GetEnumerator()
        {
            if (Interlocked.CompareExchange(ref this.<>1__state, 0, -2) == -2)
            {
                return this;
            }
            ImageList.d__0 d__ = new ImageList.d__0(0);
            d__.<>4__this = this.<>4__this;
            return d__;
        }

        [DebuggerHidden]
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.System.Collections.Generic.IEnumerable.GetEnumerator();
        }

        [DebuggerHidden]
        void IEnumerator.Reset()
        {
            throw new NotSupportedException();
        }

        void IDisposable.Dispose()
        {
        }

        // Properties
        ScriptReference IEnumerator<ScriptReference>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }
    }
}

[ParseChildren(false), AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal), AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
public class ImageListItem : IEquatable<ImageListItem>
{
    // Fields
    private string _ImageUrl;
    private string _Key;
    private string _Tag;
    private string _Text;
    private string _Tooltip;

    // Methods
    public ImageListItem()
    {
        this._Key = Guid.Empty.ToString();
        this._ImageUrl = "spacer.gif";
        this._Text = "text";
        this._Tooltip = "tooltip";
    }

    public ImageListItem(string key, string imageUrl, string text) : this(key, imageUrl, text, text, null)
    {
    }

    public ImageListItem(string key, string imageUrl, string text, string tooltip) : this(key, imageUrl, text, tooltip, null)
    {
    }

    public ImageListItem(string key, string imageUrl, string text, string tooltip, string tag)
    {
        if (string.IsNullOrEmpty(key))
        {
            throw new ArgumentNullException("key");
        }
        if (string.IsNullOrEmpty(imageUrl))
        {
            throw new ArgumentNullException("imageUrl");
        }
        if (string.IsNullOrEmpty(text))
        {
            throw new ArgumentNullException("text");
        }
        if (string.IsNullOrEmpty(tooltip))
        {
            throw new ArgumentNullException("tooltip");
        }
        this._Key = key;
        this._ImageUrl = imageUrl;
        this._Text = text;
        this._Tooltip = tooltip;
        this._Tag = tag;
    }

    public bool Equals(ImageListItem other)
    {
        return ((this.Key == other.Key) || ((this.Text == other.Text) && (this.Tag == other.Tag)));
    }

    // Properties
    public string ImageUrl
    {
        get
        {
            return this._ImageUrl;
        }
        set
        {
            if (string.IsNullOrEmpty(value))
            {
                throw new ArgumentNullException("value");
            }
            this._ImageUrl = value;
        }
    }

    public string Key
    {
        get
        {
            return this._Key;
        }
        set
        {
            if (string.IsNullOrEmpty(value))
            {
                throw new ArgumentNullException("value");
            }
            this._Key = value;
        }
    }

    public string Tag
    {
        get
        {
            return this._Tag;
        }
        set
        {
            this._Tag = value;
        }
    }

    public string Text
    {
        get
        {
            return this._Text;
        }
        set
        {
            if (string.IsNullOrEmpty(value))
            {
                throw new ArgumentNullException("value");
            }
            this._Text = value;
        }
    }

    public string Tooltip
    {
        get
        {
            return this._Tooltip;
        }
        set
        {
            if (string.IsNullOrEmpty(value))
            {
                throw new ArgumentNullException("value");
            }
            this._Tooltip = value;
        }
    }
}







[ParseChildren(false), AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal), AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
public class ImageListItemCollection : IList<ImageListItem>, ICollection<ImageListItem>, IEnumerable<ImageListItem>, IEnumerable
{
    // Fields
    private List<ImageListItem> _ImageListItems;

    // Methods
    public ImageListItemCollection()
    {
        this._ImageListItems = new List<ImageListItem>();
    }

    public ImageListItemCollection(IEnumerable<ImageListItem> collection)
    {
        this._ImageListItems = new List<ImageListItem>(collection);
    }

    public void Add(ImageListItem item)
    {
        if (!this._ImageListItems.Contains(item))
        {
            this._ImageListItems.Add(item);
        }
    }

    public void AddRange(IEnumerable<ImageListItem> collection)
    {
        this._ImageListItems.AddRange(collection);
    }

    public void Clear()
    {
        this._ImageListItems.Clear();
    }

    public bool Contains(ImageListItem item)
    {
        return this._ImageListItems.Contains(item);
    }

    public void CopyTo(ImageListItem[] array, int arrayIndex)
    {
        this._ImageListItems.CopyTo(array, arrayIndex);
    }

    public IEnumerator<ImageListItem> GetEnumerator()
    {
        return this._ImageListItems.GetEnumerator();
    }

    public int IndexOf(ImageListItem item)
    {
        return this._ImageListItems.IndexOf(item);
    }

    public void Insert(int index, ImageListItem item)
    {
        if (!this._ImageListItems.Contains(item))
        {
            this._ImageListItems.Insert(index, item);
        }
    }

    public bool Remove(ImageListItem item)
    {
        return this._ImageListItems.Remove(item);
    }

    public void RemoveAt(int index)
    {
        this._ImageListItems.RemoveAt(index);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this._ImageListItems.GetEnumerator();
    }

    public ImageListItem[] ToArray()
    {
        return this._ImageListItems.ToArray();
    }

    // Properties
    public int Count
    {
        get
        {
            return this._ImageListItems.Count;
        }
    }

    public bool IsReadOnly
    {
        get
        {
            return false;
        }
    }

    public ImageListItem this[int index]
    {
        get
        {
            return this._ImageListItems[index];
        }
        set
        {
            if (!this._ImageListItems.Contains(value))
            {
                this._ImageListItems[index] = value;
            }
        }
    }
}