TimelineClockCollection.cs source code in C# .NET

                        
Code:
                         / Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / wpf / src / Core / CSharp / System / Windows / Media / Animation / TimelineClockCollection.cs / 1 / TimelineClockCollection.cs
                        

                        
                            // ClockCollection.cs 

using System;
using System.Collections.Generic;
using System.Diagnostics; 

using SR=MS.Internal.PresentationCore.SR; 
using SRID=MS.Internal.PresentationCore.SRID; 

#pragma warning disable 1634, 1691  // suppressing PreSharp warnings 

namespace System.Windows.Media.Animation
{
    /// 
 
    /// A collection of Clock objects.
    /// 
 
    public class ClockCollection : ICollection 
    {
        #region External interface 

        #region ICollection

        #region Properties 

        /// 
 
        /// Gets the number of elements contained in the collection. 
        /// 
        ///  
        /// The number of elements contained in the collection.
        /// 
        public int Count
        { 
            get
            { 
//                 _owner.VerifyAccess(); 
                ClockGroup clockGroup = _owner as ClockGroup;
                if (clockGroup != null) 
                {
                    List childList = clockGroup.InternalChildren;
                    if (childList != null)
                    { 
                        return childList.Count;
                    } 
                } 
                return 0;
            } 
        }

        /// 

        /// 
        /// 
        ///  
        public bool IsReadOnly 
        {
            get 
            {
                return true;
            }
        } 

        #endregion // Properties 
 
        #region Methods
 
        /// 

        ///
        /// 
        public void Clear() 
        {
            throw new NotSupportedException(); 
        } 

        /// 
 
        ///
        /// 
        /// 
        ///  
        public void Add(Clock item)
        { 
            throw new NotSupportedException(); 
        }
 
        /// 

        ///
        /// 
        ///  
        /// 
        public bool Remove(Clock item) 
        { 
            throw new NotSupportedException();
        } 

        /// 

        ///
        /// 
 
        /// 
        ///  
        public bool Contains(Clock item) 
        {
            if (item == null) 
            {
                throw new ArgumentNullException("item");
            }
 
            foreach (Clock t in this)
            { 
                #pragma warning suppress 6506 // the enumerator will not contain nulls 
                if (t.Equals(item))
                    return true; 
            }

            return false;
        } 

        /// 
 
        /// Copies the elements of the collection to an array, starting at a 
        /// particular array index.
        /// 
 
        /// 
        /// The one-dimensional array that is the destination of the elements
        /// copied from the collection. The Array must have zero-based indexing.
        ///  
        /// 
        /// The zero-based index in array at which copying begins. 
        ///  
        public void CopyTo(Clock[] array, int index)
        { 
//             _owner.VerifyAccess();

            ClockGroup clockGroup = _owner as ClockGroup;
 
            if (clockGroup != null)
            { 
                List list = clockGroup.InternalChildren; 

                if (list != null) 
                {
                    // Get free parameter validation from Array.Copy
                    list.CopyTo(array, index);
                } 
            }
 
            // 
        }
 
        #endregion // Methods

        #endregion // ICollection
 
        #region IEnumerable
 
        #region Methods 

        /// 
 
        /// Returns an enumerator that can iterate through a collection.
        /// 
        /// 
        /// An enumerator that can iterate through a collection. 
        /// 
        IEnumerator IEnumerable.GetEnumerator() 
        { 
//             _owner.VerifyAccess();
 
            List list = null;
            ClockGroup clockGroup = _owner as ClockGroup;

            if (clockGroup != null) 
            {
                list = clockGroup.InternalChildren; 
            } 

            if (list != null) 
            {
                return list.GetEnumerator();
            }
            else 
            {
                return new ClockEnumerator(_owner); 
            } 
        }
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return new ClockEnumerator(_owner);
        } 

        /// 
 
        /// Checks for equality of two ClockCollections 
        /// 
        ///  
        /// Other object against which to check for equality
        /// 
        public override bool Equals(object obj)
        { 
            if (obj is ClockCollection)
            { 
                return (this == (ClockCollection)obj); 
            }
            else 
            {
                return false;
            }
        } 

        /// 
 
        /// Checks for equality of two ClockCollections 
        /// 
        ///  
        /// First ClockCollection to check for equality
        /// 
        /// 
        /// Second ClockCollection to check for equality 
        /// 
        public static bool Equals(ClockCollection objA, ClockCollection objB) 
        { 
            return (objA == objB);
        } 

        /// 

        /// Shallow comparison for equality: A and B have the same owner
        /// 
 
        /// 
        /// First ClockCollection to check for equality 
        ///  
        /// 
        /// Second ClockCollection to check for equality 
        /// 
        public static bool operator ==(ClockCollection objA, ClockCollection objB)
        {
            if (Object.ReferenceEquals(objA, objB)) 
            {
                // Exact same object. 
                return true; 
            }
            else if (   Object.ReferenceEquals(objA, null) 
                     || Object.ReferenceEquals(objB, null))
            {
                // One is null, the other isn't.
                return false; 
            }
            else 
            { 
                // Both are non-null.
#pragma warning disable 56506 // Suppress presharp warning: Parameter 'objA' to this public method must be validated:  A null-dereference can occur here. 
                return objA._owner == objB._owner;
#pragma warning restore 56506
            }
        } 

        /// 
 
        /// Shallow comparison for inequality: A and B have different owner 
        /// 
        ///  
        /// First ClockCollection to check for inequality
        /// 
        /// 
        /// Second ClockCollection to check for inequality 
        /// 
        public static bool operator !=(ClockCollection objA, ClockCollection objB) 
        { 
            return !(objA == objB);
        } 

        ///

        /// GetHashCode
        ///
 
        public override int GetHashCode()
        { 
            return _owner.GetHashCode(); 
        }
 
        #endregion // Methods

        #endregion // IEnumerable
 
        #region Properties
 
        /// 
 
        /// Gets or sets the element at the specified index.
        /// 
 
        /// 
        /// The element at the specified index.
        /// 
        public Clock this[int index] 
        {
            get 
            { 
//                 _owner.VerifyAccess();
 
                List list = null;
                ClockGroup clockGroup = _owner as ClockGroup;

                if (clockGroup != null) 
                {
                    list = clockGroup.InternalChildren; 
                } 

                if (list == null) 
                {
                    throw new ArgumentOutOfRangeException("index");
                }
 
                return list[index];
            } 
        } 

        #endregion // Properties 

        #endregion // External interface

        #region Internal implementation 

        #region Types 
 
        /// 

        /// An enumerator for a ClockCollection object. 
        /// 
        internal struct ClockEnumerator : IEnumerator
        {
 
            #region Construction
 
            /// 
 
            /// Creates an enumerator for the specified clock.
            /// 
 
            /// 
            /// The clock whose children to enumerate.
            /// 
            internal ClockEnumerator(Clock owner) 
            {
                _owner = owner; 
            } 

            #endregion // Construction 

            #region IDisposable interface

            /// 
 
            /// Disposes the enumerator.
            /// 
 
            public void Dispose() 
            {
                // The enumerator doesn't do much, so we don't have to do 
                // anything to dispose it.
            }

            #endregion // IDisposable interface 

            #region IEnumerator interface 
 
            /// 

            /// Gets the current element in the collection. 
            /// 
            /// 
            /// The current element in the collection.
            ///  
            Clock IEnumerator.Current
             { 
                get 
                {
                    throw new InvalidOperationException(SR.Get(SRID.Timing_EnumeratorOutOfRange)); 
                }
            }

            #region IEnumerator Members 

            object System.Collections.IEnumerator.Current 
            { 
                get
                { 
                    return ((IEnumerator)this).Current;
                }
            }
 
            void System.Collections.IEnumerator.Reset()
            { 
                throw new NotImplementedException(); 
            }
 
            #endregion

            /// 

            /// Advances the enumerator to the next element of the collection. 
            /// 
            ///  
            /// true if the enumerator was successfully advanced to the next 
            /// element; false if the enumerator has passed the end of the
            /// collection. 
            /// 
            public bool MoveNext()
            {
                // If the collection is no longer empty, it means it was 
                // modified and we should thrown an exception. Otherwise, we
                // are still valid, but the collection is empty so we should 
                // just return false. 

//                 _owner.VerifyAccess(); 

                ClockGroup clockGroup = _owner as ClockGroup;

                if (clockGroup != null && clockGroup.InternalChildren != null) 
                {
                    throw new InvalidOperationException(SR.Get(SRID.Timing_EnumeratorInvalidated)); 
                } 

                return false; 
            }

            #endregion // IEnumerator interface
 
            #region Internal implementation
 
            #region Data 

            private Clock   _owner; 

            #endregion // Data

            #endregion // Internal implementation 
        }
 
        #endregion // Types 

        #region Constructors 

        /// 

        /// Creates an initially empty collection of Clock objects.
        /// 
 
        /// 
        /// The Clock that owns this collection. 
        ///  
        internal ClockCollection(Clock owner)
        { 
            Debug.Assert(owner != null, "ClockCollection must have a non-null owner.");
            _owner = owner;
        }
 
        /// 

        /// Disallow parameterless constructors 
        /// 
 
        private ClockCollection()
        { 
            Debug.Assert(false, "Parameterless constructor is illegal for ClockCollection.");
        }

        #endregion 

        #region Data 
 
        private Clock       _owner;
 
        #endregion // Data

        #endregion // Internal implementation
    } 
}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
// ClockCollection.cs 

using System;
using System.Collections.Generic;
using System.Diagnostics; 

using SR=MS.Internal.PresentationCore.SR; 
using SRID=MS.Internal.PresentationCore.SRID; 

#pragma warning disable 1634, 1691  // suppressing PreSharp warnings 

namespace System.Windows.Media.Animation
{
    /// 
 
    /// A collection of Clock objects.
    /// 
 
    public class ClockCollection : ICollection 
    {
        #region External interface 

        #region ICollection

        #region Properties 

        /// 
 
        /// Gets the number of elements contained in the collection. 
        /// 
        ///  
        /// The number of elements contained in the collection.
        /// 
        public int Count
        { 
            get
            { 
//                 _owner.VerifyAccess(); 
                ClockGroup clockGroup = _owner as ClockGroup;
                if (clockGroup != null) 
                {
                    List childList = clockGroup.InternalChildren;
                    if (childList != null)
                    { 
                        return childList.Count;
                    } 
                } 
                return 0;
            } 
        }

        /// 

        /// 
        /// 
        ///  
        public bool IsReadOnly 
        {
            get 
            {
                return true;
            }
        } 

        #endregion // Properties 
 
        #region Methods
 
        /// 

        ///
        /// 
        public void Clear() 
        {
            throw new NotSupportedException(); 
        } 

        /// 
 
        ///
        /// 
        /// 
        ///  
        public void Add(Clock item)
        { 
            throw new NotSupportedException(); 
        }
 
        /// 

        ///
        /// 
        ///  
        /// 
        public bool Remove(Clock item) 
        { 
            throw new NotSupportedException();
        } 

        /// 

        ///
        /// 
 
        /// 
        ///  
        public bool Contains(Clock item) 
        {
            if (item == null) 
            {
                throw new ArgumentNullException("item");
            }
 
            foreach (Clock t in this)
            { 
                #pragma warning suppress 6506 // the enumerator will not contain nulls 
                if (t.Equals(item))
                    return true; 
            }

            return false;
        } 

        /// 
 
        /// Copies the elements of the collection to an array, starting at a 
        /// particular array index.
        /// 
 
        /// 
        /// The one-dimensional array that is the destination of the elements
        /// copied from the collection. The Array must have zero-based indexing.
        ///  
        /// 
        /// The zero-based index in array at which copying begins. 
        ///  
        public void CopyTo(Clock[] array, int index)
        { 
//             _owner.VerifyAccess();

            ClockGroup clockGroup = _owner as ClockGroup;
 
            if (clockGroup != null)
            { 
                List list = clockGroup.InternalChildren; 

                if (list != null) 
                {
                    // Get free parameter validation from Array.Copy
                    list.CopyTo(array, index);
                } 
            }
 
            // 
        }
 
        #endregion // Methods

        #endregion // ICollection
 
        #region IEnumerable
 
        #region Methods 

        /// 
 
        /// Returns an enumerator that can iterate through a collection.
        /// 
        /// 
        /// An enumerator that can iterate through a collection. 
        /// 
        IEnumerator IEnumerable.GetEnumerator() 
        { 
//             _owner.VerifyAccess();
 
            List list = null;
            ClockGroup clockGroup = _owner as ClockGroup;

            if (clockGroup != null) 
            {
                list = clockGroup.InternalChildren; 
            } 

            if (list != null) 
            {
                return list.GetEnumerator();
            }
            else 
            {
                return new ClockEnumerator(_owner); 
            } 
        }
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return new ClockEnumerator(_owner);
        } 

        /// 
 
        /// Checks for equality of two ClockCollections 
        /// 
        ///  
        /// Other object against which to check for equality
        /// 
        public override bool Equals(object obj)
        { 
            if (obj is ClockCollection)
            { 
                return (this == (ClockCollection)obj); 
            }
            else 
            {
                return false;
            }
        } 

        /// 
 
        /// Checks for equality of two ClockCollections 
        /// 
        ///  
        /// First ClockCollection to check for equality
        /// 
        /// 
        /// Second ClockCollection to check for equality 
        /// 
        public static bool Equals(ClockCollection objA, ClockCollection objB) 
        { 
            return (objA == objB);
        } 

        /// 

        /// Shallow comparison for equality: A and B have the same owner
        /// 
 
        /// 
        /// First ClockCollection to check for equality 
        ///  
        /// 
        /// Second ClockCollection to check for equality 
        /// 
        public static bool operator ==(ClockCollection objA, ClockCollection objB)
        {
            if (Object.ReferenceEquals(objA, objB)) 
            {
                // Exact same object. 
                return true; 
            }
            else if (   Object.ReferenceEquals(objA, null) 
                     || Object.ReferenceEquals(objB, null))
            {
                // One is null, the other isn't.
                return false; 
            }
            else 
            { 
                // Both are non-null.
#pragma warning disable 56506 // Suppress presharp warning: Parameter 'objA' to this public method must be validated:  A null-dereference can occur here. 
                return objA._owner == objB._owner;
#pragma warning restore 56506
            }
        } 

        /// 
 
        /// Shallow comparison for inequality: A and B have different owner 
        /// 
        ///  
        /// First ClockCollection to check for inequality
        /// 
        /// 
        /// Second ClockCollection to check for inequality 
        /// 
        public static bool operator !=(ClockCollection objA, ClockCollection objB) 
        { 
            return !(objA == objB);
        } 

        ///

        /// GetHashCode
        ///
 
        public override int GetHashCode()
        { 
            return _owner.GetHashCode(); 
        }
 
        #endregion // Methods

        #endregion // IEnumerable
 
        #region Properties
 
        /// 
 
        /// Gets or sets the element at the specified index.
        /// 
 
        /// 
        /// The element at the specified index.
        /// 
        public Clock this[int index] 
        {
            get 
            { 
//                 _owner.VerifyAccess();
 
                List list = null;
                ClockGroup clockGroup = _owner as ClockGroup;

                if (clockGroup != null) 
                {
                    list = clockGroup.InternalChildren; 
                } 

                if (list == null) 
                {
                    throw new ArgumentOutOfRangeException("index");
                }
 
                return list[index];
            } 
        } 

        #endregion // Properties 

        #endregion // External interface

        #region Internal implementation 

        #region Types 
 
        /// 

        /// An enumerator for a ClockCollection object. 
        /// 
        internal struct ClockEnumerator : IEnumerator
        {
 
            #region Construction
 
            /// 
 
            /// Creates an enumerator for the specified clock.
            /// 
 
            /// 
            /// The clock whose children to enumerate.
            /// 
            internal ClockEnumerator(Clock owner) 
            {
                _owner = owner; 
            } 

            #endregion // Construction 

            #region IDisposable interface

            /// 
 
            /// Disposes the enumerator.
            /// 
 
            public void Dispose() 
            {
                // The enumerator doesn't do much, so we don't have to do 
                // anything to dispose it.
            }

            #endregion // IDisposable interface 

            #region IEnumerator interface 
 
            /// 

            /// Gets the current element in the collection. 
            /// 
            /// 
            /// The current element in the collection.
            ///  
            Clock IEnumerator.Current
             { 
                get 
                {
                    throw new InvalidOperationException(SR.Get(SRID.Timing_EnumeratorOutOfRange)); 
                }
            }

            #region IEnumerator Members 

            object System.Collections.IEnumerator.Current 
            { 
                get
                { 
                    return ((IEnumerator)this).Current;
                }
            }
 
            void System.Collections.IEnumerator.Reset()
            { 
                throw new NotImplementedException(); 
            }
 
            #endregion

            /// 

            /// Advances the enumerator to the next element of the collection. 
            /// 
            ///  
            /// true if the enumerator was successfully advanced to the next 
            /// element; false if the enumerator has passed the end of the
            /// collection. 
            /// 
            public bool MoveNext()
            {
                // If the collection is no longer empty, it means it was 
                // modified and we should thrown an exception. Otherwise, we
                // are still valid, but the collection is empty so we should 
                // just return false. 

//                 _owner.VerifyAccess(); 

                ClockGroup clockGroup = _owner as ClockGroup;

                if (clockGroup != null && clockGroup.InternalChildren != null) 
                {
                    throw new InvalidOperationException(SR.Get(SRID.Timing_EnumeratorInvalidated)); 
                } 

                return false; 
            }

            #endregion // IEnumerator interface
 
            #region Internal implementation
 
            #region Data 

            private Clock   _owner; 

            #endregion // Data

            #endregion // Internal implementation 
        }
 
        #endregion // Types 

        #region Constructors 

        /// 

        /// Creates an initially empty collection of Clock objects.
        /// 
 
        /// 
        /// The Clock that owns this collection. 
        ///  
        internal ClockCollection(Clock owner)
        { 
            Debug.Assert(owner != null, "ClockCollection must have a non-null owner.");
            _owner = owner;
        }
 
        /// 

        /// Disallow parameterless constructors 
        /// 
 
        private ClockCollection()
        { 
            Debug.Assert(false, "Parameterless constructor is illegal for ClockCollection.");
        }

        #endregion 

        #region Data 
 
        private Clock       _owner;
 
        #endregion // Data

        #endregion // Internal implementation
    } 
}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• HttpValueCollection.cs
• SparseMemoryStream.cs
• EmptyStringExpandableObjectConverter.cs
• SqlExpander.cs
• AtomMaterializerLog.cs
• ToolStripDropDownMenu.cs
• FixedSchema.cs
• RSACryptoServiceProvider.cs
• ProviderCommandInfoUtils.cs
• XmlSchemaObjectTable.cs
• MethodToken.cs
• SafeSecurityHelper.cs
• PTManager.cs
• VirtualPath.cs
• MSG.cs
• CodeSnippetStatement.cs
• PagerSettings.cs
• ZipPackage.cs
• DataGridToolTip.cs
• RegionIterator.cs
• SocketConnection.cs
• XmlProcessingInstruction.cs
• UmAlQuraCalendar.cs
• SessionStateSection.cs
• CryptoApi.cs
• ScrollChrome.cs
• FragmentNavigationEventArgs.cs
• Cursors.cs
• ProgressBarBrushConverter.cs
• XmlToDatasetMap.cs
• CompleteWizardStep.cs
• HWStack.cs
• DefaultTextStore.cs
• MachineKeySection.cs
• isolationinterop.cs
• ScriptControlDescriptor.cs
• InkCanvasSelectionAdorner.cs
• ValidatorCompatibilityHelper.cs
• TemplateControlBuildProvider.cs
• CorrelationHandle.cs
• Tuple.cs
• CommandBinding.cs
• __TransparentProxy.cs
• ScrollViewer.cs
• BaseDataBoundControl.cs
• __ComObject.cs
• MostlySingletonList.cs
• StorageEntitySetMapping.cs
• AvTraceFormat.cs
• XmlAtomicValue.cs
• XmlNamespaceDeclarationsAttribute.cs
• BuildProvider.cs
• StringResourceManager.cs
• BitmapImage.cs
• XmlILTrace.cs
• ParameterElementCollection.cs
• Substitution.cs
• FileSystemEnumerable.cs
• XmlAnyElementAttributes.cs
• IndexedWhereQueryOperator.cs
• Hashtable.cs
• TimelineCollection.cs
• DockProviderWrapper.cs
• DynamicActionMessageFilter.cs
• ProcessHost.cs
• OLEDB_Enum.cs
• String.cs
• TrackingConditionCollection.cs
• SystemPens.cs
• SignatureGenerator.cs
• BufferedReceiveManager.cs
• CalendarAutoFormat.cs
• RenderData.cs
• Scene3D.cs
• DebugInfoExpression.cs
• RoutedEventHandlerInfo.cs
• InternalsVisibleToAttribute.cs
• SimpleWorkerRequest.cs
• Certificate.cs
• TextServicesHost.cs
• SchemaObjectWriter.cs
• GridItemCollection.cs
• RetrieveVirtualItemEventArgs.cs
• SynchronizedDispatch.cs
• precedingsibling.cs
• XmlTextReader.cs
• GACMembershipCondition.cs
• Util.cs
• Select.cs
• SystemResourceHost.cs
• PageCache.cs
• TableLayout.cs
• LinkUtilities.cs
• RectAnimationBase.cs
• ConnectionConsumerAttribute.cs
• ADMembershipProvider.cs
• CodeAttributeDeclarationCollection.cs
• ChildDocumentBlock.cs
• VirtualPath.cs
• Token.cs