ObjectListFieldCollection.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / MIT / System / Web / UI / MobileControls / ObjectListFieldCollection.cs / 1305376 / ObjectListFieldCollection.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

using System; 
using System.Collections; 
using System.Diagnostics;
using System.Globalization; 
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls; 
using System.Security.Permissions;
 
namespace System.Web.UI.MobileControls 
{
    /* 
     * Object List Field Collection class.
     *
     * Copyright (c) 2000 Microsoft Corporation
     */ 

    ///  
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)] 
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    [Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")] 
    public class ObjectListFieldCollection : ArrayListCollectionBase, IObjectListFieldCollection, IStateManager
    {
        private ObjectList _owner;
        private bool _marked = false; 
        private bool _fieldsSetDirty = false;
        // Used for primary field collection (the one modified by the user). 
 
        internal ObjectListFieldCollection(ObjectList owner) : base(new ArrayList())
        { 
            _owner = owner;
        }

        // Used for autogenerated field collections. 

        internal ObjectListFieldCollection(ObjectList owner, ArrayList fields) : base(fields) 
        { 
            _owner = owner;
            foreach (ObjectListField field in fields) 
            {
                field.SetOwner(owner);
            }
        } 

        ///  
        public ObjectListField[] GetAll() 
        {
            int n = Count; 
            ObjectListField[] allFields = new ObjectListField[n];
            if (n > 0)
            {
                Items.CopyTo(0, allFields, 0, n); 
            }
            return allFields; 
        } 

        ///  
        public void SetAll(ObjectListField[] value)
        {
            Items = new ArrayList(value);
            foreach(ObjectListField field in Items) 
            {
                field.SetOwner(_owner); 
            } 
            if(_marked)
            { 
                SetFieldsDirty();
            }
        }
 
        /// 
        public ObjectListField this[int index] 
        { 
            get
            { 
                return (ObjectListField)Items[index];
            }
        }
 
        /// 
        public void Add(ObjectListField field) 
        { 
            AddAt(-1, field);
        } 

        /// 
        public void AddAt(int index, ObjectListField field)
        { 
            if (index == -1)
            { 
                Items.Add(field); 
            }
            else 
            {
                Items.Insert(index, field);
            }
            if (_marked) 
            {
                if (!_fieldsSetDirty && index > -1) 
                { 
                    SetFieldsDirty();
                } 
                else
                {
                    ((IStateManager)field).TrackViewState();
                    field.SetDirty(); 
                }
            } 
            field.SetOwner(_owner); 
            NotifyOwnerChange();
        } 

        private void SetFieldsDirty()
        {
            foreach (ObjectListField fld in Items) 
            {
                ((IStateManager)fld).TrackViewState(); 
                fld.SetDirty(); 
            }
            _fieldsSetDirty = true; 
        }

        /// 
        public void Clear() 
        {
            Items.Clear(); 
            if (_marked) 
            {
                // Each field will be marked dirty as it is added. 
                _fieldsSetDirty = true;
            }
            NotifyOwnerChange();
        } 

        ///  
        public void RemoveAt(int index) 
        {
            if ((index >= 0) && (index < Count)) 
            {
                Items.RemoveAt(index);
            }
            if(_marked && !_fieldsSetDirty) 
            {
                SetFieldsDirty(); 
            } 
            NotifyOwnerChange();
        } 

        /// 
        public void Remove(ObjectListField field)
        { 
            int index = IndexOf(field);
            if (index >= 0) 
            { 
                RemoveAt(index);
            } 
        }

        /// 
        public int IndexOf(ObjectListField field) 
        {
            if (field != null) 
            { 
                return Items.IndexOf(field, 0, Count);
            } 
            return -1;
        }

        ///  
        public int IndexOf(String fieldIDOrName)
        { 
            ArrayList fields = Items; 
            int i = 0;
            foreach (ObjectListField field in fields) 
            {
                String id = field.UniqueID;
                if (id != null && String.Compare(id, fieldIDOrName, StringComparison.OrdinalIgnoreCase) == 0)
                { 
                    return i;
                } 
                i++; 
            }
            return -1; 
        }

        private void NotifyOwnerChange()
        { 
            if (_owner != null)
            { 
                _owner.OnFieldChanged(true);    // fieldAddedOrRemoved = true 
            }
        } 

        /////////////////////////////////////////////////////////////////////////
        //  STATE MANAGEMENT
        ///////////////////////////////////////////////////////////////////////// 

        ///  
        protected bool IsTrackingViewState 
        {
            get 
            {
                return _marked;
            }
        } 

        ///  
        protected void TrackViewState() 
        {
            _marked = true; 
            foreach (IStateManager field in Items)
            {
                field.TrackViewState();
            } 
        }
 
        ///  
        protected void LoadViewState(Object savedState)
        { 
            if (savedState != null)
            {
                Object[] stateArray = (Object[]) savedState;
                bool allFieldsSaved = (bool) stateArray[0]; 
                if (allFieldsSaved)
                { 
                    // All fields are in view state.  Any fields loaded until now are invalid. 
                    ClearFieldsViewState();
                } 
                Object[] fieldStates = (Object[])stateArray[1];
                EnsureCount(fieldStates.Length);
                for (int i = 0; i < fieldStates.Length; i++)
                { 
                    ((IStateManager)Items[i]).LoadViewState(fieldStates[i]);
                } 
                if (allFieldsSaved) 
                {
                    SetFieldsDirty(); 
                }
            }
        }
 
        /// 
        protected Object SaveViewState() 
        { 
            int fieldsCount = Count;
            if (fieldsCount > 0) 
            {
                Object[] fieldStates = new Object[fieldsCount];
                bool haveState = _fieldsSetDirty;
                for (int i = 0; i < fieldsCount; i++) 
                {
                    fieldStates[i] = ((IStateManager)Items[i]).SaveViewState(); 
                    if (fieldStates[i] != null) 
                    {
                        haveState = true; 
                    }
                }
                if (haveState)
                { 
                    return new Object[]{_fieldsSetDirty, fieldStates};
                } 
            } 
            return null;
        } 

        private void EnsureCount(int count)
        {
 
            int diff = Count - count;
            if (diff > 0) 
            { 
                Items.RemoveRange(count, diff);
                NotifyOwnerChange(); 
            }
            else
            {
                // Set owner = null, to avoid multiple change notifications. 
                // We'll call it just once later.
 
                ObjectList prevOwner = _owner; 
                _owner = null;
                for (int i = diff; i < 0; i++) 
                {
                    ObjectListField field = new ObjectListField();
                    Add(field);
                    field.SetOwner(prevOwner); 
                }
                _owner = prevOwner; 
                NotifyOwnerChange(); 
            }
        } 

        private void ClearFieldsViewState()
        {
            foreach (ObjectListField field in Items) 
            {
                field.ClearViewState(); 
            } 
        }
 
        #region Implementation of IStateManager
        /// 
        bool IStateManager.IsTrackingViewState {
            get { 
                return IsTrackingViewState;
            } 
        } 

        ///  
        void IStateManager.LoadViewState(object state) {
            LoadViewState(state);
        }
 
        /// 
        void IStateManager.TrackViewState() { 
            TrackViewState(); 
        }
 
        /// 
        object IStateManager.SaveViewState() {
            return SaveViewState();
        } 
        #endregion
    } 
} 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK