ByteKeyFrameCollection.cs source code in C# .NET

                        Code:
                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Core / System / Windows / Media / Animation / Generated / ByteKeyFrameCollection.cs / 1 / ByteKeyFrameCollection.cs
                        
                        
                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// This file was generated, please do not edit it directly. 
// 
// Please see [....]/default.aspx/Microsoft.Projects.Avalon/MilCodeGen.html for more information.
// 
//---------------------------------------------------------------------------

using MS.Internal;
 
using System;
using System.Collections; 
using System.Collections.Generic; 
using System.ComponentModel;
using System.Diagnostics; 
using System.Globalization;
using System.Windows.Media.Animation;
using System.Windows.Media.Media3D;
 
namespace System.Windows.Media.Animation
{ 
    ///  
    /// This collection is used in conjunction with a KeyFrameByteAnimation
    /// to animate a Byte property value along a set of key frames. 
    /// 
    public class ByteKeyFrameCollection : Freezable, IList
    {
        #region Data 

        private List _keyFrames; 
        private static ByteKeyFrameCollection s_emptyCollection; 

        #endregion 

        #region Constructors

        ///  
        /// Creates a new ByteKeyFrameCollection.
        ///  
        public ByteKeyFrameCollection() 
            : base()
        { 
            _keyFrames = new List< ByteKeyFrame>(2);
        }

        #endregion 

        #region Static Methods 
 
        /// 
        /// An empty ByteKeyFrameCollection. 
        /// 
        public static ByteKeyFrameCollection Empty
        {
            get 
            {
                if (s_emptyCollection == null) 
                { 
                    ByteKeyFrameCollection emptyCollection = new ByteKeyFrameCollection();
 
                    emptyCollection._keyFrames = new List< ByteKeyFrame>(0);
                    emptyCollection.Freeze();

                    s_emptyCollection = emptyCollection; 
                }
 
                return s_emptyCollection; 
            }
        } 

        #endregion

        #region Freezable 

        ///  
        /// Creates a freezable copy of this ByteKeyFrameCollection. 
        /// 
        /// The copy 
        public new ByteKeyFrameCollection Clone()
        {
            return (ByteKeyFrameCollection)base.Clone();
        } 

        ///  
        /// Implementation of Freezable.CreateInstanceCore. 
        /// 
        /// The new Freezable. 
        protected override Freezable CreateInstanceCore()
        {
            return new ByteKeyFrameCollection();
        } 

        ///  
        /// Implementation of Freezable.CloneCore. 
        /// 
        protected override void CloneCore(Freezable sourceFreezable) 
        {
            ByteKeyFrameCollection sourceCollection = (ByteKeyFrameCollection) sourceFreezable;
            base.CloneCore(sourceFreezable);
 
            int count = sourceCollection._keyFrames.Count;
 
            _keyFrames = new List< ByteKeyFrame>(count); 

            for (int i = 0; i < count; i++) 
            {
                ByteKeyFrame keyFrame = (ByteKeyFrame)sourceCollection._keyFrames[i].Clone();
                _keyFrames.Add(keyFrame);
                OnFreezablePropertyChanged(null, keyFrame); 
            }
        } 
 

        ///  
        /// Implementation of Freezable.CloneCurrentValueCore.
        /// 
        protected override void CloneCurrentValueCore(Freezable sourceFreezable)
        { 
            ByteKeyFrameCollection sourceCollection = (ByteKeyFrameCollection) sourceFreezable;
            base.CloneCurrentValueCore(sourceFreezable); 
 
            int count = sourceCollection._keyFrames.Count;
 
            _keyFrames = new List< ByteKeyFrame>(count);

            for (int i = 0; i < count; i++)
            { 
                ByteKeyFrame keyFrame = (ByteKeyFrame)sourceCollection._keyFrames[i].CloneCurrentValue();
                _keyFrames.Add(keyFrame); 
                OnFreezablePropertyChanged(null, keyFrame); 
            }
        } 


        /// 
        /// Implementation of Freezable.GetAsFrozenCore. 
        /// 
        protected override void GetAsFrozenCore(Freezable sourceFreezable) 
        { 
            ByteKeyFrameCollection sourceCollection = (ByteKeyFrameCollection) sourceFreezable;
            base.GetAsFrozenCore(sourceFreezable); 

            int count = sourceCollection._keyFrames.Count;

            _keyFrames = new List< ByteKeyFrame>(count); 

            for (int i = 0; i < count; i++) 
            { 
                ByteKeyFrame keyFrame = (ByteKeyFrame)sourceCollection._keyFrames[i].GetAsFrozen();
                _keyFrames.Add(keyFrame); 
                OnFreezablePropertyChanged(null, keyFrame);
            }
        }
 

        ///  
        /// Implementation of Freezable.GetCurrentValueAsFrozenCore. 
        /// 
        protected override void GetCurrentValueAsFrozenCore(Freezable sourceFreezable) 
        {
            ByteKeyFrameCollection sourceCollection = (ByteKeyFrameCollection) sourceFreezable;
            base.GetCurrentValueAsFrozenCore(sourceFreezable);
 
            int count = sourceCollection._keyFrames.Count;
 
            _keyFrames = new List< ByteKeyFrame>(count); 

            for (int i = 0; i < count; i++) 
            {
                ByteKeyFrame keyFrame = (ByteKeyFrame)sourceCollection._keyFrames[i].GetCurrentValueAsFrozen();
                _keyFrames.Add(keyFrame);
                OnFreezablePropertyChanged(null, keyFrame); 
            }
        } 
 
        /// 
        /// 
        /// 
        protected override bool FreezeCore(bool isChecking)
        {
            bool canFreeze = base.FreezeCore(isChecking); 

            for (int i = 0; i < _keyFrames.Count && canFreeze; i++) 
            { 
                canFreeze &= Freezable.Freeze(_keyFrames[i], isChecking);
            } 

            return canFreeze;
        }
 
        #endregion
 
        #region IEnumerable 

        ///  
        /// Returns an enumerator of the ByteKeyFrames in the collection.
        /// 
        public IEnumerator GetEnumerator()
        { 
            ReadPreamble();
 
            return _keyFrames.GetEnumerator(); 
        }
 
        #endregion

        #region ICollection
 
        /// 
        /// Returns the number of ByteKeyFrames in the collection. 
        ///  
        public int Count
        { 
            get
            {
                ReadPreamble();
 
                return _keyFrames.Count;
            } 
        } 

        ///  
        /// See ICollection.IsSynchronized.
        /// 
        public bool IsSynchronized
        { 
            get
            { 
                ReadPreamble(); 

                return (IsFrozen || Dispatcher != null); 
            }
        }

        ///  
        /// See ICollection.SyncRoot.
        ///  
        public object SyncRoot 
        {
            get 
            {
                ReadPreamble();

                return ((ICollection)_keyFrames).SyncRoot; 
            }
        } 
 
        /// 
        /// Copies all of the ByteKeyFrames in the collection to an 
        /// array.
        /// 
        void ICollection.CopyTo(Array array, int index)
        { 
            ReadPreamble();
 
            ((ICollection)_keyFrames).CopyTo(array, index); 
        }
 
        /// 
        /// Copies all of the ByteKeyFrames in the collection to an
        /// array of ByteKeyFrames.
        ///  
        public void CopyTo(ByteKeyFrame[] array, int index)
        { 
            ReadPreamble(); 

            _keyFrames.CopyTo(array, index); 
        }

        #endregion
 
        #region IList
 
        ///  
        /// Adds a ByteKeyFrame to the collection.
        ///  
        int IList.Add(object keyFrame)
        {
            return Add((ByteKeyFrame)keyFrame);
        } 

        ///  
        /// Adds a ByteKeyFrame to the collection. 
        /// 
        public int Add(ByteKeyFrame keyFrame) 
        {
            if (keyFrame == null)
            {
                throw new ArgumentNullException("keyFrame"); 
            }
 
            WritePreamble(); 

            OnFreezablePropertyChanged(null, keyFrame); 
            _keyFrames.Add(keyFrame);

            WritePostscript();
 
            return _keyFrames.Count - 1;
        } 
 
        /// 
        /// Removes all ByteKeyFrames from the collection. 
        /// 
        public void Clear()
        {
            WritePreamble(); 

            if (_keyFrames.Count > 0) 
            { 
                for (int i = 0; i < _keyFrames.Count; i++)
                { 
                    OnFreezablePropertyChanged(_keyFrames[i], null);
                }

                _keyFrames.Clear(); 

                WritePostscript(); 
            } 
        }
 
        /// 
        /// Returns true of the collection contains the given ByteKeyFrame.
        /// 
        bool IList.Contains(object keyFrame) 
        {
            return Contains((ByteKeyFrame)keyFrame); 
        } 

        ///  
        /// Returns true of the collection contains the given ByteKeyFrame.
        /// 
        public bool Contains(ByteKeyFrame keyFrame)
        { 
            ReadPreamble();
 
            return _keyFrames.Contains(keyFrame); 
        }
 
        /// 
        /// Returns the index of a given ByteKeyFrame in the collection.
        /// 
        int IList.IndexOf(object keyFrame) 
        {
            return IndexOf((ByteKeyFrame)keyFrame); 
        } 

        ///  
        /// Returns the index of a given ByteKeyFrame in the collection.
        /// 
        public int IndexOf(ByteKeyFrame keyFrame)
        { 
            ReadPreamble();
 
            return _keyFrames.IndexOf(keyFrame); 
        }
 
        /// 
        /// Inserts a ByteKeyFrame into a specific location in the collection.
        /// 
        void IList.Insert(int index, object keyFrame) 
        {
            Insert(index, (ByteKeyFrame)keyFrame); 
        } 

        ///  
        /// Inserts a ByteKeyFrame into a specific location in the collection.
        /// 
        public void Insert(int index, ByteKeyFrame keyFrame)
        { 
            if (keyFrame == null)
            { 
                throw new ArgumentNullException("keyFrame"); 
            }
 
            WritePreamble();

            OnFreezablePropertyChanged(null, keyFrame);
            _keyFrames.Insert(index, keyFrame); 

            WritePostscript(); 
        } 

        ///  
        /// Returns true if the collection is frozen.
        /// 
        public bool IsFixedSize
        { 
            get
            { 
                ReadPreamble(); 

                return IsFrozen; 
            }
        }

        ///  
        /// Returns true if the collection is frozen.
        ///  
        public bool IsReadOnly 
        {
            get 
            {
                ReadPreamble();

                return IsFrozen; 
            }
        } 
 
        /// 
        /// Removes a ByteKeyFrame from the collection. 
        /// 
        void IList.Remove(object keyFrame)
        {
            Remove((ByteKeyFrame)keyFrame); 
        }
 
        ///  
        /// Removes a ByteKeyFrame from the collection.
        ///  
        public void Remove(ByteKeyFrame keyFrame)
        {
            WritePreamble();
 
            if (_keyFrames.Contains(keyFrame))
            { 
                OnFreezablePropertyChanged(keyFrame, null); 
                _keyFrames.Remove(keyFrame);
 
                WritePostscript();
            }
        }
 
        /// 
        /// Removes the ByteKeyFrame at the specified index from the collection. 
        ///  
        public void RemoveAt(int index)
        { 
            WritePreamble();

            OnFreezablePropertyChanged(_keyFrames[index], null);
            _keyFrames.RemoveAt(index); 

            WritePostscript(); 
        } 

        ///  
        /// Gets or sets the ByteKeyFrame at a given index.
        /// 
        object IList.this[int index]
        { 
            get
            { 
                return this[index]; 
            }
            set 
            {
                this[index] = (ByteKeyFrame)value;
            }
        } 

        ///  
        /// Gets or sets the ByteKeyFrame at a given index. 
        /// 
        public ByteKeyFrame this[int index] 
        {
            get
            {
                ReadPreamble(); 

                return _keyFrames[index]; 
            } 
            set
            { 
                if (value == null)
                {
                    throw new ArgumentNullException(String.Format(CultureInfo.InvariantCulture, "ByteKeyFrameCollection[{0}]", index));
                } 

                WritePreamble(); 
 
                if (value != _keyFrames[index])
                { 
                    OnFreezablePropertyChanged(_keyFrames[index], value);
                    _keyFrames[index] = value;

                    Debug.Assert(_keyFrames[index] != null); 

                    WritePostscript(); 
                } 
            }
        } 

        #endregion
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
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
ByteKeyFrameCollection.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
