DoubleAnimationClockResource.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Core / System / Windows / Media / Animation / Generated / DoubleAnimationClockResource.cs / 2 / DoubleAnimationClockResource.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 System;
using System.Windows; 
using System.Windows.Media;
using System.Windows.Media.Composition; 
using System.Diagnostics; 
using System.Runtime.InteropServices;
using System.Security; 

namespace System.Windows.Media.Animation
{
    ///  
    /// DoubleAnimationClockResource class.
    /// AnimationClockResource classes refer to an AnimationClock and a base 
    /// value.  They implement DUCE.IResource, and thus can be used to produce 
    /// a render-side resource which represents the current value of this
    /// AnimationClock. 
    /// They subscribe to the Changed event on the AnimationClock and ensure
    /// that the resource's current value is up to date.
    /// 
    internal class DoubleAnimationClockResource: AnimationClockResource, DUCE.IResource 
    {
        ///  
        /// Constructor for public DoubleAnimationClockResource. 
        /// This constructor accepts the base value and AnimationClock.
        /// Note that since there is no current requirement that we be able to set or replace either the 
        /// base value or the AnimationClock, this is the only way to initialize an instance of
        /// DoubleAnimationClockResource.
        /// Also, we currently Assert that the resource is non-null, since without mutability
        /// such a resource isn't needed. 
        /// We can easily extend this class if/when new requirements arise.
        ///  
        ///  Double - The base value.  
        ///  AnimationClock - cannot be null. 
        public DoubleAnimationClockResource( 
            Double baseValue,
            AnimationClock animationClock
            ): base( animationClock )
        { 
            _baseValue = baseValue;
        } 
 
        #region Public Properties
 
        /// 
        /// BaseValue Property - typed accessor for BaseValue.
        /// 
        public Double BaseValue 
        {
            get 
            { 
                return _baseValue;
            } 
        }

        /// 
        /// CurrentValue Property - typed accessor for CurrentValue 
        /// 
        public Double CurrentValue 
        { 
            get
            { 
                if (_animationClock != null)
                {
                    // No handoff for DrawingContext animations so we use the
                    // BaseValue as the defaultOriginValue and the 
                    // defaultDestinationValue.  We call the Timeline's GetCurrentValue
                    // directly to avoid boxing 
                    return ((DoubleAnimationBase)(_animationClock.Timeline)).GetCurrentValue( 
                        _baseValue,  // defaultOriginValue
                        _baseValue,  // defaultDesinationValue 
                        _animationClock); // clock
                }
                else
                { 
                    return _baseValue;
                } 
            } 
        }
 
        #endregion Public Properties

        #region DUCE
 
        //
        // Method which returns the DUCE type of this class. 
        // The base class needs this type when calling CreateOrAddRefOnChannel. 
        // By providing this via a virtual, we avoid a per-instance storage cost.
        // 
        protected override DUCE.ResourceType ResourceType
        {
            get
            { 
                 return DUCE.ResourceType.TYPE_DOUBLERESOURCE;
            } 
        } 

        ///  
        /// UpdateResource - This method is called to update the render-thread
        /// resource on a given channel.
        /// 
        ///  The DUCE.ResourceHandle for this resource on this channel.  
        ///  The channel on which to update the render-thread resource. 
        ///  
        ///     Critical: This code calls into an unsafe code block 
        ///     TreatAsSafe: This code does not return any critical data.It is ok to expose
        ///     Channels can handle bad pointers and will not affect other appdomains or processes 
        /// 
        [SecurityCritical,SecurityTreatAsSafe]
        protected override void UpdateResource(
            DUCE.ResourceHandle handle, 
            DUCE.Channel channel)
        { 
            DUCE.MILCMD_DOUBLERESOURCE cmd = new DUCE.MILCMD_DOUBLERESOURCE(); 

            cmd.Type = MILCMD.MilCmdDoubleResource; 
            cmd.Handle = handle;
            cmd.Value = CurrentValue;

            unsafe 
            {
                channel.SendCommand( 
                    (byte*)&cmd, 
                    sizeof(DUCE.MILCMD_DOUBLERESOURCE));
            } 

            // Validate this resource
            IsResourceInvalid = false;
        } 

        #endregion DUCE 
 
        private Double _baseValue;
    } 
}

// 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