Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Classe LinearDecimalKeyFrame

Anima do valor de Decimal do quadro chave anterior para seu próprio Value usando interpolação linear.

Namespace:  System.Windows.Media.Animation
Assembly:  PresentationCore (em PresentationCore.dll)
XMLNS para XAML http://schemas.microsoft.com/winfx/2006/xaml/presentation, http://schemas.microsoft.com/netfx/2007/xaml/presentation

public class LinearDecimalKeyFrame : DecimalKeyFrame
<LinearDecimalKeyFrame .../>

O tipo LinearDecimalKeyFrame expõe os membros a seguir.

  NomeDescrição
Método públicoLinearDecimalKeyFrame()Inicializa uma nova instância da classe LinearDecimalKeyFrame.
Método públicoLinearDecimalKeyFrame(Decimal)Inicializa uma nova instância da classe LinearDecimalKeyFrame com o valor final especificado.
Método públicoLinearDecimalKeyFrame(Decimal, KeyTime)Inicializa uma nova instância da classe LinearDecimalKeyFrame com os momentos especificados de valor e de chave final.
Superior

  NomeDescrição
Propriedade públicaCanFreeze Obtém um valor que indica se o objeto pode ser feito inalterável. (Herdado de Freezable.)
Propriedade públicaDependencyObjectType Obtém o DependencyObjectType que envolve o tipo de instância da CLR. (Herdado de DependencyObject.)
Propriedade públicaDispatcherObtém o Dispatcher esse DispatcherObject está associado. (Herdado de DispatcherObject.)
Propriedade públicaIsFrozenObtém um valor que indica se o objeto é atualmente pode ser modificado. (Herdado de Freezable.)
Propriedade públicaIsSealed Obtém um valor que indica se essa instância atualmente é selada (somente leitura). (Herdado de DependencyObject.)
Propriedade públicaKeyTime Obtém ou define a hora em que destino do quadro chave Value devem ser atingidos. (Herdado de DecimalKeyFrame.)
Propriedade públicaValue Obtém ou define o valor de destino do quadro chave. (Herdado de DecimalKeyFrame.)
Superior

  NomeDescrição
Método públicoCheckAccessDetermina se o segmento de chamada tem acesso a este DispatcherObject. (Herdado de DispatcherObject.)
Método públicoClearValue(DependencyProperty)Limpa o valor local de uma propriedade. A propriedade a ser limpa é especificada por um identificador da DependencyProperty. (Herdado de DependencyObject.)
Método públicoClearValue(DependencyPropertyKey)Limpa o valor local de uma propriedade somente leitura. A propriedade a ser limpa é especificada por uma DependencyPropertyKey. (Herdado de DependencyObject.)
Método públicoCloneCria um clone modificável da Freezable, fazendo cópias profunda dos valores do objeto. Ao copiar propriedades de dependência do objeto, esse método copia expressões (que não mais poderão resolver) mas não animações ou seus valores atuais. (Herdado de Freezable.)
Método protegidoCloneCoreTorna a instância um clone (cópia em profundidade) do especificado Freezable usando valores de propriedade de base (sem animação). (Herdado de Freezable.)
Método públicoCloneCurrentValueCria um clone modificável (cópia em profundidade) da Freezable usando seus valores atuais. (Herdado de Freezable.)
Método protegidoCloneCurrentValueCoreTorna a instância um clone modificável (cópia em profundidade) do especificado Freezable usando valores de propriedade atual. (Herdado de Freezable.)
Método públicoCoerceValueConverte o valor especificado propriedade de dependência. Isso é feito chamando qualquer CoerceValueCallback especificada na metadados de propriedade para a propriedade de dependência conforme ela existe na chamada de função DependencyObject. (Herdado de DependencyObject.)
Método protegidoCreateInstance
Inicializa uma nova instância da classe Freezable .
(Herdado de Freezable.)
Método protegidoCreateInstanceCoreCria uma nova instância de LinearDecimalKeyFrame. (Substitui Freezable.CreateInstanceCore().)
Método públicoEqualsDetermina se um fornecido DependencyObject é equivalente à atual DependencyObject. (Herdado de DependencyObject.)
Método protegidoFinalize Permite um objeto tentar liberar recursos e executar outras operações de limpeza antes que ele seja recuperado pela coleta de lixo. (Herdado de Object.)
Método públicoFreeze()Torna o objeto atual unmodifiable e define sua IsFrozen propriedade para true. (Herdado de Freezable.)
Método protegidoFreezeCoreFaz com que o Freezable object unmodifiable ou testa se podem ser feita unmodifiable. (Herdado de Freezable.)
Método públicoGetAsFrozenCria uma cópia congelada da Freezable, usando valores de propriedade de base (sem animação). Porque a cópia está congelada, qualquer subobjetos congelados são copiados por referência. (Herdado de Freezable.)
Método protegidoGetAsFrozenCoreTorna a instância um clone congelado especificado Freezable usando valores de propriedade de base (sem animação). (Herdado de Freezable.)
Método públicoGetCurrentValueAsFrozenCria uma cópia congelada da Freezable usando valores de propriedade atual. Porque a cópia está congelada, qualquer subobjetos congelados são copiados por referência. (Herdado de Freezable.)
Método protegidoGetCurrentValueAsFrozenCoreTorna a instância atual um clone congelado especificado Freezable. Se o objeto tem propriedades de dependência animado, seus valores atuais de animados são copiados. (Herdado de Freezable.)
Método públicoGetHashCodeObtém um código de hash para este DependencyObject. (Herdado de DependencyObject.)
Método públicoGetLocalValueEnumeratorCria um enumerador especializado para determinar quais propriedades de dependência localmente têm definir valores nessa DependencyObject. (Herdado de DependencyObject.)
Método públicoGetType Obtém o Type da instância atual. (Herdado de Object.)
Método públicoGetValueRetorna o valor atual de efetivo de um propriedade de dependência nesta instância de um DependencyObject. (Herdado de DependencyObject.)
Método públicoInterpolateValueRetorna o valor interpolado de um quadro-chave específico ao incremento de progresso fornecido. (Herdado de DecimalKeyFrame.)
Método protegidoInterpolateValueCoreInterpola, em uma forma linear, entre o valor do quadro chave anterior e o valor do quadro chave atual, usando o incremento fornecido de progresso. (Substitui DecimalKeyFrame.InterpolateValueCore(Decimal, Double).)
Método públicoInvalidatePropertyAvalia o valor efetivo de propriedade de dependência especificado (Herdado de DependencyObject.)
Método protegidoMemberwiseCloneCria uma cópia superficial do Object atual. (Herdado de Object.)
Método protegidoOnChangedChamado quando o atual Freezable objeto é modificado. (Herdado de Freezable.)
Método protegidoOnFreezablePropertyChanged(DependencyObject, DependencyObject)Garante que são estabelecidos ponteiros de contexto apropriado para um DependencyObjectType membro de dados que só foi definido. (Herdado de Freezable.)
Método protegidoOnFreezablePropertyChanged(DependencyObject, DependencyObject, DependencyProperty)Este membro dá suporte a Windows Presentation Foundation (WPF) infra-estrutura e não se destina a ser usado diretamente em seu código. (Herdado de Freezable.)
Método protegidoOnPropertyChangedSubstitui o DependencyObject a implementação de OnPropertyChanged também chamar Changed manipuladores em resposta a uma alteração propriedade de dependência do tipo Freezable. (Herdado de Freezable.)
Método públicoReadLocalValueRetorna o valor de local de um propriedade de dependência, se ele existir. (Herdado de DependencyObject.)
Método protegidoReadPreambleGarante que o Freezable está sendo acessado de um segmento válido. Os herdeiros de Freezable deve chamar esse método no início de qualquer API que lê os membros de dados que não são propriedades de dependência. (Herdado de Freezable.)
Método públicoSetCurrentValueDefine o valor de um propriedade de dependência sem alterar sua fonte de valor. (Herdado de DependencyObject.)
Método públicoSetValue(DependencyProperty, Object)Define o valor de local de um propriedade de dependência, especificado por seu identificador de propriedade de dependência. (Herdado de DependencyObject.)
Método públicoSetValue(DependencyPropertyKey, Object)Define o valor de local de somente leitura propriedade de dependência, especificado pelo DependencyPropertyKey identificador de propriedade de dependência. (Herdado de DependencyObject.)
Método protegidoShouldSerializePropertyRetorna um valor que indica se os processos de serialização devem serializar o valor para o fornecido propriedade de dependência. (Herdado de DependencyObject.)
Método públicoToStringRetorna uma string que representa o objeto atual. (Herdado de Object.)
Método públicoVerifyAccessImpõe que o segmento de chamada tem acesso a este DispatcherObject. (Herdado de DispatcherObject.)
Método protegidoWritePostscriptEleva o Changed evento para o Freezable e invoca seu OnChanged método. Classes que derivam de Freezable deve chamar este método no final de qualquer API que modifica os membros da classe que não são armazenados como Propriedades de dependência. (Herdado de Freezable.)
Método protegidoWritePreambleVerifica se o Freezable não está congelada e que ele está sendo acessado de um contexto de segmentação válido. Freezable os herdeiros devem chamar esse método no início de qualquer API que grava os membros de dados que não são propriedades de dependência. (Herdado de Freezable.)
Superior

  NomeDescrição
Evento públicoChangedOcorre quando o Freezable ou um objeto nele contido é modificado. (Herdado de Freezable.)
Superior

  NomeDescrição
Implementação explícita da interfacePropriedade particularIKeyFrame.ValueObtém ou define o valor associado com uma KeyTime instância. (Herdado de DecimalKeyFrame.)
Superior

Essa classe é usada como parte de DecimalKeyFrameCollection em conjunto com DecimalAnimationUsingKeyFrames para animar um valor de propriedade de Decimal ao longo de um conjunto de quadros chave.

Um quadro chave define um segmento de DecimalAnimationUsingKeyFrames a qual pertence. Cada quadro chave tem um destino Value e KeyTime. KeyTime especifica o tempo em que Value de quadro chave deve ser alcançado. Um quadro chave anima do valor de destino do quadro chave anterior para seu próprio valor de destino. Ele se inicia quando o quadro chave anterior e termina quando seus próprios momento chave são alcançados.

Quadros-chave lineares como LinearDecimalKeyFrame criar uma interpolação linear suave, entre valores.

Este exemplo mostra como animar o valor de uma propriedade, que recebe um Double, usando quadros chave.

O exemplo a seguir move um retângulo através de uma tela. O exemplo usa a classe DoubleAnimationUsingKeyFrames para animar a propriedade X de uma TranslateTransform aplicada a um Rectangle. Esta animação, que é repetida indefinidamente, usa três quadros chave da seguinte forma:

  1. Durante os primeiros três segundos, usa-se uma instância da classe LinearDoubleKeyFrame para mover o retângulo ao longo de um caminho a uma taxa constante a partir da sua posição inicial até a posição 500. Quadros-chave lineares como LinearDoubleKeyFrame criam uma transição linear suave entre valores.

  2. No final do quarto segundo, usa-se uma instância da classe DiscreteDoubleKeyFrame para repentinamente mover o retângulo para a próxima posição. Quadros de chave discretos como DiscreteDoubleKeyFrame criam pulos repentinos entre valores. Nesse exemplo, o retângulo está na posição inicial e de repente aparece na posição 500.

  3. Durante os dois segundos finais, usa-se uma instância da classe SplineDoubleKeyFrame para mover o retângulo de volta para sua posição inicial. Quadros de chave de Spline como SplineDoubleKeyFrame criam transições variáveis entre valores de acordo com os valores da propriedade KeySpline. Neste exemplo, o retângulo começa movendo-se lentamente e acelera exponencialmente ao se aproximar o final do segmento de tempo.


using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Shapes;
using System.Windows.Media.Animation;
using System.Windows.Media;

namespace Microsoft.Samples.KeyFrameExamples
{
    /// <summary>
    /// This example shows how to use the DoubleAnimationUsingKeyFrames class to
    /// animate the position of an object.
    /// Key frame animations enable you to create complex animations 
    /// by specifying multiple destination values
    /// and controlling the animation's interpolation method.
    /// </summary>
    public class AltDoubleAnimationUsingKeyFramesExample : Page
    {
        public AltDoubleAnimationUsingKeyFramesExample()
        {
            Title = "DoubleAnimationUsingKeyFrames Example";
            Background = Brushes.White;
            Margin = new Thickness(20);

            // Create a NameScope for this page so that
            // Storyboards can be used.
            NameScope.SetNameScope(this, new NameScope());

            // Create a rectangle.
            Rectangle aRectangle = new Rectangle();
            aRectangle.Width = 100;
            aRectangle.Height = 100;
            aRectangle.Stroke = Brushes.Black;
            aRectangle.StrokeThickness = 5;

            // Create a Canvas to contain and
            // position the rectangle.
            Canvas containerCanvas = new Canvas();
            containerCanvas.Width = 610;
            containerCanvas.Height = 300;
            containerCanvas.Children.Add(aRectangle);
            Canvas.SetTop(aRectangle, 100);
            Canvas.SetLeft(aRectangle, 10);         

            // Create a TranslateTransform to 
            // move the rectangle.
            TranslateTransform animatedTranslateTransform = 
                new TranslateTransform();
            aRectangle.RenderTransform = animatedTranslateTransform;  

            // Assign the TranslateTransform a name so that
            // it can be targeted by a Storyboard.
            this.RegisterName(
                "AnimatedTranslateTransform", animatedTranslateTransform);

            // Create a DoubleAnimationUsingKeyFrames to
            // animate the TranslateTransform.
            DoubleAnimationUsingKeyFrames translationAnimation 
                = new DoubleAnimationUsingKeyFrames();
            translationAnimation.Duration = TimeSpan.FromSeconds(6);

            // Animate from the starting position to 500
            // over the first second using linear
            // interpolation.
            translationAnimation.KeyFrames.Add(
                new LinearDoubleKeyFrame(
                    500, // Target value (KeyValue)
                    KeyTime.FromTimeSpan(TimeSpan.FromSeconds(3))) // KeyTime
                );

            // Animate from 500 (the value of the previous key frame) 
            // to 400 at 4 seconds using discrete interpolation.
            // Because the interpolation is discrete, the rectangle will appear
            // to "jump" from 500 to 400.
            translationAnimation.KeyFrames.Add(
                new DiscreteDoubleKeyFrame(
                    400, // Target value (KeyValue)
                    KeyTime.FromTimeSpan(TimeSpan.FromSeconds(4))) // KeyTime
                );

            // Animate from 400 (the value of the previous key frame) to 0
            // over two seconds, starting at 4 seconds (the key time of the
            // last key frame) and ending at 6 seconds.
            translationAnimation.KeyFrames.Add(
                new SplineDoubleKeyFrame(
                    0, // Target value (KeyValue)
                    KeyTime.FromTimeSpan(TimeSpan.FromSeconds(6)), // KeyTime
                    new KeySpline(0.6,0.0,0.9,0.0) // KeySpline
                    )
                );

            // Set the animation to repeat forever. 
            translationAnimation.RepeatBehavior = RepeatBehavior.Forever;

            // Set the animation to target the X property
            // of the object named "AnimatedTranslateTransform."
            Storyboard.SetTargetName(translationAnimation, "AnimatedTranslateTransform");
            Storyboard.SetTargetProperty(
                translationAnimation, new PropertyPath(TranslateTransform.XProperty));

            // Create a storyboard to apply the animation.
            Storyboard translationStoryboard = new Storyboard();
            translationStoryboard.Children.Add(translationAnimation);

            // Start the storyboard after the rectangle loads.
            aRectangle.Loaded += delegate(object sender, RoutedEventArgs e)
            {
                translationStoryboard.Begin(this);
            };

            Content = containerCanvas;
        }

    }
}



<!-- This example shows how to use the DoubleAnimationUsingKeyFrames to 
     animate the position of an object. 
     Key frame animations enable you to create complex animations 
     by specifying multiple destination values
     and controlling the animation's interpolation method.
-->
<Page 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  Title="DoubleAnimationUsingKeyFrames Example"
  Background="White" Margin="20">       
  <Canvas Width="610" Height="300">

    <!-- The position of this rectangle is animated using 
         a key frame animation. -->
    <Rectangle 
      Canvas.Top="100"
      Canvas.Left="10"
      Height="100"
      Width="100"
      Stroke="Black"
      StrokeThickness="5">
      <Rectangle.RenderTransform>
        <TranslateTransform x:Name="AnimatedTranslateTransform" />
      </Rectangle.RenderTransform>

      <Rectangle.Triggers>
        <EventTrigger RoutedEvent="Rectangle.Loaded">
          <BeginStoryboard>
            <Storyboard>

              <!-- Animate the TranslateTransform.X property using 3 KeyFrames
                   which animates the rectangle along a straight line. 
                   This animation repeats indefinitely. -->
              <DoubleAnimationUsingKeyFrames
                Storyboard.TargetName="AnimatedTranslateTransform"
                Storyboard.TargetProperty="X"
                Duration="0:0:6"
                RepeatBehavior="Forever">

                <!-- Using a LinearDoubleKeyFrame, the rectangle moves 
                     steadily from its starting position to 500 over 
                     the first 3 seconds.  -->
                <LinearDoubleKeyFrame Value="500" KeyTime="0:0:3" />

                <!-- Using a DiscreteDoubleKeyFrame, the rectangle suddenly 
                     appears at 400 after the fourth second of the animation. -->
                <DiscreteDoubleKeyFrame Value="400" KeyTime="0:0:4" />

                <!-- Using a SplineDoubleKeyFrame, the rectangle moves 
                     back to its starting point. The
                     animation starts out slowly at first and then speeds up. 
                     This KeyFrame ends after the 6th
                     second. -->
                <SplineDoubleKeyFrame KeySpline="0.6,0.0 0.9,0.00" Value="0" KeyTime="0:0:6" />
              </DoubleAnimationUsingKeyFrames>
            </Storyboard>
          </BeginStoryboard>
        </EventTrigger>
      </Rectangle.Triggers>
    </Rectangle>
  </Canvas>
</Page>


No exemplo completo, consulte o  Exemplo de animação KeyFrame.

Para consistência com outros exemplos de animação, as versões de código deste exemplo usam um objeto Storyboard para aplicar o DoubleAnimationUsingKeyFrames. Como alternativa, ao aplicar uma animação única em código, é mais simples usar o método BeginAnimation em vez de usar um Storyboard. Para um exemplo, consulte Como animar uma propriedade sem usar um storyboard.

.NET Framework

Com suporte em: 4.5, 4, 3.5, 3.0

.NET Framework Client Profile

Com suporte em: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Função Server Core sem suporte), Windows Server 2008 R2 (Função Server Core com suporte com o SP1 ou posterior, Itanium sem suporte)

O .NET Framework não oferece suporte a todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte Requisitos do sistema do .NET Framework.

Qualquer estático (Shared no Visual Basic) membro público desse tipo é thread-safe. Não há garantia de que qualquer membro de instância seja thread-safe.

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft