Exportar (0) Imprimir
Expandir todo

Storyboard.TargetName (Propiedad asociada)

Actualización: noviembre 2007

Obtiene o establece el nombre del objeto que se va a animar. El objeto debe pertenecer a la clase FrameworkElement, FrameworkContentElemento Freezable.

Espacio de nombres:  System.Windows.Media.Animation
Ensamblado:  PresentationFramework (en PresentationFramework.dll)
XMLNS para XAML: http://schemas.microsoft.com/winfx/xaml/presentation

See GetTargetName, SetTargetName
See GetTargetName, SetTargetName
See GetTargetName, SetTargetName
<object Storyboard.TargetName="string" .../>

Valor de propiedad

Tipo: System.String
El nombre de FrameworkElement, FrameworkContentElement o Freezable que se va a animar.

Campo de identificador

TargetNameProperty

Propiedades de metadatos establecidas en true.

None

La definición de esta propiedad es opcional. Si no se especifica TargetName, las animaciones de un guión gráfico se aplican a uno de los elementos siguientes:

  • Si el guión gráfico al que pertenece la animación se ha iniciado utilizando BeginStoryboard, el elemento que se establece como destino es el que posee la acción BeginStoryboard que activa el guión gráfico.

  • Si el guión gráfico se ha iniciado utilizando el método Begin, el objeto FrameworkElement o FrameworkContentElement que se especificó cuando se inició el guión gráfico con el método Begin es el que se establece como destino.

Cuando esta propiedad se establece en una escala de tiempo con elementos secundarios, esas escalas de tiempo secundarias "heredan" el valor TargetName del elemento primario a menos que especifiquen su propio valor.

Establecer un objeto como destino

Cuando utiliza XAML, realiza una de las dos acciones siguientes para establecer un objeto como destino de un guión gráfico:

Cuando utiliza código, establece un objeto como destino a través del método RegisterName para asignar un nombre al objeto.

En este ejemplo se muestra cómo utilizar un objeto Storyboard para animar propiedades. Para animar una propiedad utilizando un objeto Storyboard, cree una animación para cada propiedad que desee animar y cree también un objeto Storyboard para contener las animaciones.

El tipo de propiedad determina el tipo de animación a utilizar. Por ejemplo, para animar una propiedad que toma valores Double, utilice un objeto DoubleAnimation. Las propiedades asociadasTargetName y TargetProperty especifique el objeto y la propiedad a la que se aplica la animación.

Para iniciar un guión gráfico en Lenguaje de marcado de aplicaciones extensible (XAML), utilice una acción BeginStoryboard y un objeto EventTrigger. El objeto EventTriggerinicia la acción BeginStoryboard cuando se produce el evento especificado por su propiedad RoutedEvent. La acción BeginStoryboard inicia el objeto Storyboard.

En el ejemplo siguiente se utiliza objetos Storyboard para animar dos controles Button. Para realizar la primera modificación del botón en tamaño, se anima su propiedad Width. Para hacer que el segundo botón cambie de color, se utiliza la propiedad Color del objeto SolidColorBrush para establecer la propiedad Background del botón que se anima.

<!-- StoryboardExample.xaml
     Uses storyboards to animate properties. -->
<Page
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  WindowTitle="Animate Properties with Storyboards">

  <Border Background="White">
    <StackPanel Margin="30" HorizontalAlignment="Left" MinWidth="500">

      <TextBlock>Storyboard Animation Example</TextBlock>

      <!-- The width of this button is animated. -->
      <Button Name="myWidthAnimatedButton"
        Height="30" Width="200" HorizontalAlignment="Left">
        A Button   
        <Button.Triggers>

          <!-- Animates the width of the first button 
               from 200 to 300. -->         
          <EventTrigger RoutedEvent="Button.Click">
            <BeginStoryboard>
              <Storyboard>           
                <DoubleAnimation Storyboard.TargetName="myWidthAnimatedButton"
                  Storyboard.TargetProperty="Width"
                  From="200" To="300" Duration="0:0:3" />
              </Storyboard>
            </BeginStoryboard>
          </EventTrigger>
        </Button.Triggers>
      </Button>

      <!-- The color of the brush used to paint this button is animated. -->
      <Button Height="30" Width="200" 
        HorizontalAlignment="Left">Another Button
        <Button.Background>
          <SolidColorBrush x:Name="myAnimatedBrush" Color="Blue" />
        </Button.Background>
        <Button.Triggers>

        <!-- Animates the color of the brush used to paint 
             the second button from red to blue . -->             
          <EventTrigger RoutedEvent="Button.Click">    
            <BeginStoryboard>
              <Storyboard>
                <ColorAnimation 
                  Storyboard.TargetName="myAnimatedBrush"
                  Storyboard.TargetProperty="Color"
                  From="Red" To="Blue" Duration="0:0:7" />
              </Storyboard>
            </BeginStoryboard>
          </EventTrigger>
        </Button.Triggers>
      </Button>
    </StackPanel>
  </Border>
</Page>


ms616981.alert_note(es-es,VS.90).gifNota:

Aunque las animaciones pueden destinarse a un objeto FrameworkElement, tal como Control o Panel, o a un objeto Freezable, tal como Brush o Transform, solamente los elementos del marco tienen una propiedad Name. Para asignar un nombre a un elemento inmovilizable para que pueda servir de destino para una animación, utilice Atributo x:Name, como muestra el ejemplo anterior.

Si utiliza el código, debe crear un objeto NameScope para un objeto FrameworkElement y registrar los nombres de los objetos a animar con FrameworkElement. Para iniciar las animación en código, utilice una acción BeginStoryboard con un objeto EventTrigger. Opcionalmente, puede utilizar un controlador de eventos y el método Begin de un objeto Storyboard. En el siguiente ejemplo, se muestra cómo utilizar el método Begin.

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

namespace Microsoft.Samples.Animation.AnimatingWithStoryboards
{


    // Uses a storyboard to animate the properties
    // of two buttons.
    public class StoryboardExample : Page
    {

        public StoryboardExample()
        {
            // Create a name scope for the page.
            NameScope.SetNameScope(this, new NameScope());

            this.WindowTitle = "Animate Properties using Storyboards";
            StackPanel myStackPanel = new StackPanel();
            myStackPanel.MinWidth = 500;
            myStackPanel.Margin = new Thickness(30);
            myStackPanel.HorizontalAlignment = HorizontalAlignment.Left;
            TextBlock myTextBlock = new TextBlock();
            myTextBlock.Text = "Storyboard Animation Example";
            myStackPanel.Children.Add(myTextBlock);

            //
            // Create and animate the first button.
            //

            // Create a button.
            Button myWidthAnimatedButton = new Button();
            myWidthAnimatedButton.Height = 30;
            myWidthAnimatedButton.Width = 200;
            myWidthAnimatedButton.HorizontalAlignment = HorizontalAlignment.Left;
            myWidthAnimatedButton.Content = "A Button";

            // Set the Name of the button so that it can be referred
            // to in the storyboard that's created later.
            // The ID doesn't have to match the variable name;
            // it can be any unique identifier.
            myWidthAnimatedButton.Name = "myWidthAnimatedButton";

            // Register the name with the page to which the button belongs.
            this.RegisterName(myWidthAnimatedButton.Name, myWidthAnimatedButton);

            // Create a DoubleAnimation to animate the width of the button.
            DoubleAnimation myDoubleAnimation = new DoubleAnimation();
            myDoubleAnimation.From = 200;
            myDoubleAnimation.To = 300;
            myDoubleAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(3000));          

            // Configure the animation to target the button's Width property.
            Storyboard.SetTargetName(myDoubleAnimation, myWidthAnimatedButton.Name); 
            Storyboard.SetTargetProperty(myDoubleAnimation, new PropertyPath(Button.WidthProperty));

            // Create a storyboard to contain the animation.
            Storyboard myWidthAnimatedButtonStoryboard = new Storyboard();
            myWidthAnimatedButtonStoryboard.Children.Add(myDoubleAnimation);

            // Animate the button width when it's clicked.
            myWidthAnimatedButton.Click += delegate(object sender, RoutedEventArgs args)
                {
                    myWidthAnimatedButtonStoryboard.Begin(myWidthAnimatedButton);
                };


            myStackPanel.Children.Add(myWidthAnimatedButton);

            //
            // Create and animate the second button.
            //

            // Create a second button.
            Button myColorAnimatedButton = new Button();
            myColorAnimatedButton.Height = 30;
            myColorAnimatedButton.Width = 200;
            myColorAnimatedButton.HorizontalAlignment = HorizontalAlignment.Left;
            myColorAnimatedButton.Content = "Another Button";

            // Create a SolidColorBrush to paint the button's background.
            SolidColorBrush myBackgroundBrush = new SolidColorBrush();
            myBackgroundBrush.Color = Colors.Blue;

            // Because a Brush isn't a FrameworkElement, it doesn't
            // have a Name property to set. Instead, you just
            // register a name for the SolidColorBrush with
            // the page where it's used.
            this.RegisterName("myAnimatedBrush", myBackgroundBrush);

            // Use the brush to paint the background of the button.
            myColorAnimatedButton.Background = myBackgroundBrush;

            // Create a ColorAnimation to animate the button's background.
            ColorAnimation myColorAnimation = new ColorAnimation();
            myColorAnimation.From = Colors.Red;
            myColorAnimation.To = Colors.Blue;
            myColorAnimation.Duration = new Duration(TimeSpan.FromMilliseconds(7000));    

            // Configure the animation to target the brush's Color property.
            Storyboard.SetTargetName(myColorAnimation, "myAnimatedBrush");                        
            Storyboard.SetTargetProperty(myColorAnimation, new PropertyPath(SolidColorBrush.ColorProperty));    

            // Create a storyboard to contain the animation.
            Storyboard myColorAnimatedButtonStoryboard = new Storyboard();
            myColorAnimatedButtonStoryboard.Children.Add(myColorAnimation);

            // Animate the button background color when it's clicked.
            myColorAnimatedButton.Click += delegate(object sender, RoutedEventArgs args)
                {
                    myColorAnimatedButtonStoryboard.Begin(myColorAnimatedButton);
                };


            myStackPanel.Children.Add(myColorAnimatedButton);
            this.Content = myStackPanel;

        }
    }
}


Para obtener el ejemplo completo, vea Ejemplo Property Animation. Para obtener más información sobre animaciones y guiones gráficos, vea Información general sobre animaciones.

Si utiliza código, no estará limitado a utilizar objetos Storyboard para animar las propiedades. Para obtener más información y ejemplos, vea Cómo: Animar una propiedad sin utilizar un guión gráfico y Cómo: Animar una propiedad usando un objeto AnimationClock.

Más código

Cómo: Definir un ámbito de nombresPara animar con Storyboard en código, debe crear un objeto NameScope y registrar los nombres de los objetos de destino para el elemento que posee ese ámbito de nombres. En el ejemplo siguiente se crea un objeto NameScope para myMainPanel. Se agregan dos botones, button1 y button2, al panel, y se registran sus nombres. Se crean varias animaciones y un Storyboard. El método Begin del guión gráfico se utiliza para iniciar las animaciones.

Windows Vista

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

.NET Framework

Compatible con: 3.5, 3.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft