CompositionObject Clase
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Clase base de la API de composición que representa un nodo en la estructura del árbol visual.
Los objetos de composición son la estructura de árbol visual en la que se usan y se basan todas las demás características de la API de composición. La API permite a los desarrolladores definir y crear uno o varios objetos Visual que representan un nodo único en un árbol visual.
[WebHostHidden]
public ref class CompositionObject : IClosablepublic ref class CompositionObject : IClosablepublic ref class CompositionObject : IClosable, IAnimationObject/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
[WebHostHidden]
class CompositionObject : IClosable/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 131072)]
class CompositionObject : IClosable/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 131072)]
class CompositionObject : IClosable, IAnimationObject[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public class CompositionObject : System.IDisposable[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 131072)]
public class CompositionObject : System.IDisposable[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 131072)]
public class CompositionObject : System.IDisposable, IAnimationObjectPublic Class CompositionObject
Implements IDisposablePublic Class CompositionObject
Implements IAnimationObject, IDisposable- Herencia
- Derivado
- Atributos
- Implementaciones
Requisitos de Windows
| Familia de dispositivos |
Windows 10 (se introdujo en la versión 10.0.10240.0)
|
| API contract |
Windows.Foundation.UniversalApiContract (se introdujo en la versión v1.0)
|
Ejemplos
En este ejemplo se muestra cómo se puede usar la API de composición para crear una aplicación independiente sin usar XAML, WWA o DirectX. El ejemplo inicializa un nuevo Compositor y, a continuación, crea un grafo de escena con dos objetos SpriteVisual .
using System;
using System.Numerics;
using Windows.ApplicationModel.Core;
using Windows.UI;
using Windows.UI.Composition;
using Windows.UI.Core;
namespace HelloCompositionCs
{
public sealed class HelloComposition : IFrameworkView
{
//------------------------------------------------------------------------------
//
// HelloComposition.Initialize
//
// This method is called during startup to associate the IFrameworkView with the
// CoreApplicationView.
//
//------------------------------------------------------------------------------
void IFrameworkView.Initialize(CoreApplicationView view)
{
_view = view;
}
//------------------------------------------------------------------------------
//
// HelloComposition.SetWindow
//
// This method is called when the CoreApplication has created a new CoreWindow,
// allowing the application to configure the window and start producing content
// to display.
//
//------------------------------------------------------------------------------
void IFrameworkView.SetWindow(CoreWindow window)
{
_window = window;
InitNewComposition();
}
//------------------------------------------------------------------------------
//
// HelloComposition.Load
//
// This method is called when a specific page is being loaded in the
// application. It is not used for this application.
//
//------------------------------------------------------------------------------
void IFrameworkView.Load(string unused)
{
}
//------------------------------------------------------------------------------
//
// HelloComposition.Run
//
// This method is called by CoreApplication.Run to actually run the
// dispatcher's message pump.
//
//------------------------------------------------------------------------------
void IFrameworkView.Run()
{
_window.Activate();
_window.Dispatcher.ProcessEvents(CoreProcessEventsOption.ProcessUntilQuit);
}
//------------------------------------------------------------------------------
//
// HelloComposition.Uninitialize
//
// This method is called during shutdown to disconnect the CoreApplicationView,
// and CoreWindow from the IFrameworkView.
//
//------------------------------------------------------------------------------
void IFrameworkView.Uninitialize()
{
_window = null;
_view = null;
}
//------------------------------------------------------------------------------
//
// HelloComposition.InitNewComposition
//
// This method is called by SetWindow, where we initialize Composition after
// the CoreWindow has been created.
//
//------------------------------------------------------------------------------
void InitNewComposition()
{
//
// Set up Windows.UI.Composition Compositor, root ContainerVisual, and associate with
// the CoreWindow.
//
_compositor = new Compositor();
_root = _compositor.CreateContainerVisual();
_view.CompositionRootVisual = _root;
//
// Create a simple scene.
//
var child1 = _compositor.CreateSpriteVisual();
child1.Offset = new Vector2(50.0f, 50.0f);
child1.Size = new Vector2(200, 200);
child1.Brush = _compositor.CreateColorBrush(Color.FromArgb(0xFF, 0x00, 0xCC, 0x00));
_root.Children.InsertAtTop(child1);
var child2 = _compositor.CreateSpriteVisual();
child2.Offset = new Vector2(50.0f, 50.0f);
child2.Size = new Vector2(200, 200);
child2.Brush = _compositor.CreateColorBrush(Color.FromArgb(0xFF, 0x00, 0x00, 0xCC));
child1.Children.InsertAtTop(child2);
}
// CoreWindow / CoreApplicationView
private CoreWindow _window;
private CoreApplicationView _view;
// Windows.UI.Composition
private Compositor _compositor;
private ContainerVisual _root;
}
public sealed class HelloCompositionFactory : IFrameworkViewSource
{
//------------------------------------------------------------------------------
//
// HelloCompositionFactory.CreateView
//
// This method is called by CoreApplication to provide a new IFrameworkView for
// a CoreWindow that is being created.
//
//------------------------------------------------------------------------------
IFrameworkView IFrameworkViewSource.CreateView()
{
return new HelloComposition();
}
//------------------------------------------------------------------------------
//
// main
//
//------------------------------------------------------------------------------
static int Main(string[] args)
{
CoreApplication.Run(new HelloCompositionFactory());
return 0;
}
}
} // namespace HelloCompositionCs
En este ejemplo se muestra cómo construir y recorrer un árbol sencillo de objetos visuales para cambiar la opacidad sin usar XAML, WWA o DirectX. Este ejemplo se basa en el ejemplo anterior para mostrar cómo se crean los objetos visuales secundarios, se agregan y se cambian las propiedades.
En este escenario se crea una jerarquía de árbol visual de objetos visuales. Una vez creado un Compositor, se usa para crear objetos que, a continuación, se pueden administrar.
// Copyright (c) Microsoft Corporation. All rights reserved.
using System;
using System.Numerics;
using Windows.ApplicationModel.Core;
using Windows.Foundation;
using Windows.UI;
using Windows.UI.Composition;
using Windows.UI.Core;
namespace VisualTreeCs
{
public sealed class VisualTree : IFrameworkView
{
//------------------------------------------------------------------------------
//
// VisualTree.Initialize
//
// This method is called during startup to associate the IFrameworkView with the
// CoreApplicationView.
//
//------------------------------------------------------------------------------
void IFrameworkView.Initialize(CoreApplicationView view)
{
_view = view;
_random = new Random();
}
//------------------------------------------------------------------------------
//
// VisualTree.SetWindow
//
// This method is called when the CoreApplication has created a new CoreWindow,
// allowing the application to configure the window and start producing content
// to display.
//
//------------------------------------------------------------------------------
void IFrameworkView.SetWindow(CoreWindow window)
{
_window = window;
InitNewComposition();
_window.PointerPressed += OnPointerPressed;
_window.PointerMoved += OnPointerMoved;
_window.PointerReleased += OnPointerReleased;
}
//------------------------------------------------------------------------------
//
// VisualTree.OnPointerPressed
//
// This method is called when the user touches the screen, taps it with a stylus
// or clicks the mouse.
//
//------------------------------------------------------------------------------
void OnPointerPressed(CoreWindow window, PointerEventArgs args)
{
Point position = args.CurrentPoint.Position;
//
// Walk our list of visuals to determine who, if anybody, was selected
//
foreach (var child in _root.Children)
{
//
// Did we hit this child?
//
Vector2 offset = child.Offset;
Vector2 size = child.Size;
if ((position.X >= offset.X) &&
(position.X < offset.X + size.X) &&
(position.Y >= offset.Y) &&
(position.Y < offset.Y + size.Y))
{
//
// This child was hit. Since the children are stored back to front,
// the last one hit is the front-most one so it wins
//
_currentVisual = child;
_offsetBias = new Vector2((float)(offset.X - position.X),
(float)(offset.Y - position.Y));
}
}
//
// If a visual was hit, bring it to the front of the Z order
//
if (_currentVisual != null)
{
ContainerVisual parent = _currentVisual.Parent as ContainerVisual;
parent.Children.Remove(_currentVisual);
parent.Children.InsertAtTop(_currentVisual);
}
}
//------------------------------------------------------------------------------
//
// VisualTree.OnPointerMoved
//
// This method is called when the user moves their finger, stylus or mouse with
// a button pressed over the screen.
//
//------------------------------------------------------------------------------
void OnPointerMoved(CoreWindow window, PointerEventArgs args)
{
//
// If a visual is selected, drag it with the pointer position and
// make it opaque while we drag it
//
if (_currentVisual != null)
{
Point position = args.CurrentPoint.Position;
_currentVisual.Opacity = 1.0f;
_currentVisual.Offset = new Vector2((float)(position.X + _offsetBias.X),
(float)(position.Y + _offsetBias.Y));
}
}
//------------------------------------------------------------------------------
//
// VisualTree.OnPointerReleased
//
// This method is called when the user lifts their finger or stylus from the
// screen, or lifts the mouse button.
//
//------------------------------------------------------------------------------
void OnPointerReleased(CoreWindow window, PointerEventArgs args)
{
//
// If a visual was selected, make it transparent again when it is
// released
//
if (_currentVisual != null)
{
_currentVisual.Opacity = 0.8f;
_currentVisual = null;
}
}
//------------------------------------------------------------------------------
//
// VisualTree.Load
//
// This method is called when a specific page is being loaded in the
// application. It is not used for this application.
//
//------------------------------------------------------------------------------
void IFrameworkView.Load(string unused)
{
}
//------------------------------------------------------------------------------
//
// VisualTree.Run
//
// This method is called by CoreApplication.Run to actually run the
// dispatcher's message pump.
//
//------------------------------------------------------------------------------
void IFrameworkView.Run()
{
_window.Activate();
_window.Dispatcher.ProcessEvents(CoreProcessEventsOption.ProcessUntilQuit);
}
//------------------------------------------------------------------------------
//
// VisualTree.Uninitialize
//
// This method is called during shutdown to disconnect the CoreApplicationView,
// and CoreWindow from the IFrameworkView.
//
//------------------------------------------------------------------------------
void IFrameworkView.Uninitialize()
{
_window = null;
_view = null;
}
//------------------------------------------------------------------------------
//
// VisualTree.InitNewComposition
//
// This method is called by SetWindow, where we initialize Composition after
// the CoreWindow has been created.
//
//------------------------------------------------------------------------------
void InitNewComposition()
{
//
// Set up Windows.UI.Composition Compositor, root ContainerVisual, and associate with
// the CoreWindow.
//
_compositor = new Compositor();
_root = _compositor.CreateContainerVisual();
_view.CompositionRootVisual = _root;
//
// Create a few visuals for our window
//
for (int index = 0; index < 20; index++)
{
_root.Children.InsertAtTop(CreateChildElement());
}
}
//------------------------------------------------------------------------------
//
// VisualTree.CreateChildElement
//
// Creates a small sub-tree to represent a visible element in our application.
//
//------------------------------------------------------------------------------
Visual CreateChildElement()
{
//
// Each element consists of two visuals, which produce the appearance
// of a framed rectangle
//
var visual = _compositor.CreateSpriteVisual();
//
// Position this visual randomly within our window
//
visual.Offset = new Vector2((float)(_random.NextDouble() * 400), (float)(_random.NextDouble() * 400));
//
// The outer rectangle is always white
//
visual.Brush = _compositor.CreateColorBrush( Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF) );
visual.Size = new Vector2(100.0f, 100.0f);
//
// The inner rectangle is inset from the outer by three pixels all around
//
var child = _compositor.CreateSpriteVisual();
visual.Children.InsertAtTop(child);
child.Offset = new Vector2(3.0f, 3.0f);
child.Size = new Vector2(94.0f, 94.0f);
//
// Pick a random color for every rectangle
//
byte red = (byte)(0xFF * (0.2f + (_random.NextDouble() / 0.8f)));
byte green = (byte)(0xFF * (0.2f + (_random.NextDouble() / 0.8f)));
byte blue = (byte)(0xFF * (0.2f + (_random.NextDouble() / 0.8f)));
child.Brush = _compositor.CreateColorBrush( Color.FromArgb(0xFF, red, green, blue) );
//
// Make the subtree root visual partially transparent. This will cause each visual in the subtree
// to render partially transparent, since a visual's opacity is multiplied with its parent's
// opacity
//
visual.Opacity = 0.8f;
return visual;
}
// CoreWindow / CoreApplicationView
private CoreWindow _window;
private CoreApplicationView _view;
// Windows.UI.Composition
private Compositor _compositor;
private ContainerVisual _root;
private Visual _currentVisual;
private Vector2 _offsetBias;
// Helpers
private Random _random;
}
public sealed class VisualTreeFactory : IFrameworkViewSource
{
//------------------------------------------------------------------------------
//
// VisualTreeFactory.CreateView
//
// This method is called by CoreApplication to provide a new IFrameworkView for
// a CoreWindow that is being created.
//
//------------------------------------------------------------------------------
IFrameworkView IFrameworkViewSource.CreateView()
{
return new VisualTree();
}
//------------------------------------------------------------------------------
//
// main
//
//------------------------------------------------------------------------------
static int Main(string[] args)
{
CoreApplication.Run(new VisualTreeFactory());
return 0;
}
}
} // namespace VisualTreeCs
Comentarios
Los objetos se crean mediante un objeto Compositor . Los objetos de composición solo pueden ser contenedores o pueden contener contenido. La API facilita el uso al ofrecer un conjunto claro de objetos Visual para tareas específicas que existen en una jerarquía de objetos:
Visual: objeto base, la mayoría de las propiedades están aquí y las heredan los otros objetos Visual.
ContainerVisual: se deriva del objeto Visual y agrega la capacidad para crear los elementos secundarios.
SpriteVisual : se deriva de ContainerVisual y contiene contenido en forma de imágenes, efectos y cadenas de intercambio.
Compositor : administra la relación entre una aplicación y el proceso del compositor del sistema. Las animaciones actualizan las propiedades de cualquier objeto de composición animable (como Visual). Hay dos tipos de animaciones:
KeyFrameAnimation: animaciones basadas en tiempo con dos o más fotogramas clave. Estos fotogramas son marcadores, lo que permite a los desarrolladores definir cuál debe ser el valor animado en el momento especificado. Además, las animaciones se pueden ajustar especificando cómo la animación interpola (combina) los valores entre fotogramas clave. KeyFrameAnimation tiene muchas subclases que admiten un tipo diferente de valor de fotograma clave.
ExpressionAnimation: animaciones que usan una expresión matemática para especificar cómo se debe calcular el valor animado cada fotograma. Las expresiones pueden hacer referencia a propiedades de objetos de composición. ExpressionAnimations no se basan en el tiempo y se procesan cada fotograma (si es necesario).
Objetos visuales primitivos
Los objetos visuales primitivos (como SpriteVisual) describen el contenido visual en la pantalla y las opciones de representación que se aplicarán a ese contenido.
Efectos
Los efectos se pueden adjuntar al árbol visual para provocar cambios dinámicos de píxeles en el contenido de origen, como imágenes o árboles de objetos visuales.
Un efecto puede ser operaciones simples, como una desaturación, operaciones más complicadas, como desenfoques, o operaciones de mezcla A B muy complejas, como fundidos cruzados.
Consulte la sección de comentarios de CompositionEffectBrush para obtener información adicional sobre cómo crear y usar efectos.
Historial de versiones
| Versión de Windows | Versión del SDK | Valor agregado |
|---|---|---|
| 1607 | 14393 | Comentario |
| 1607 | 14393 | ImplicitAnimations |
| 1607 | 14393 | StartAnimationGroup |
| 1607 | 14393 | StopAnimationGroup |
| 1709 | 16299 | DispatcherQueue |
| 1803 | 17134 | TryGetAnimationController |
| 1809 | 17763 | PopulatePropertyInfo |
| 1809 | 17763 | StartAnimationGroupWithIAnimationObject |
| 1809 | 17763 | StartAnimationWithIAnimationObject |
Propiedades
| Comment |
Cadena que se va a asociar con compositionObject. |
| Compositor |
Compositor que se usa para crear este CompositionObject. |
| Dispatcher |
Distribuidor de CompositionObject. |
| DispatcherQueue |
Obtiene dispatcherQueue para CompostionObject. |
| ImplicitAnimations |
Colección de animaciones implícitas adjuntas a este objeto. |
| Properties |
Colección de propiedades asociadas a CompositionObject. |
Métodos
| Close() |
Cierra compositionObject y libera los recursos del sistema. |
| ConnectAnimation(String, CompositionAnimation) |
Conecta y animación. |
| DisconnectAnimation(String) |
Desconecta una animación. |
| Dispose() |
Realiza tareas definidas por la aplicación asociadas a la liberación o al restablecimiento de recursos no administrados. |
| PopulatePropertyInfo(String, AnimationPropertyInfo) |
Define una propiedad que se puede animar. |
| StartAnimation(String, CompositionAnimation) |
Conecta una animación con la propiedad especificada del objeto e inicia la animación. |
| StartAnimation(String, CompositionAnimation, AnimationController) |
Conecta una animación con la propiedad especificada del objeto e inicia la animación. |
| StartAnimationGroup(ICompositionAnimationBase) |
Inicia un grupo de animación. El método StartAnimationGroup en CompositionObject permite iniciar CompositionAnimationGroup. Todas las animaciones del grupo se iniciarán al mismo tiempo en el objeto . |
| StartAnimationGroupWithIAnimationObject(IAnimationObject, ICompositionAnimationBase) |
Inicia un grupo de animaciones en el destino especificado. |
| StartAnimationWithIAnimationObject(IAnimationObject, String, CompositionAnimation) |
Conecta una animación con la propiedad especificada del objeto de destino e inicia la animación. |
| StopAnimation(String) |
Desconecta una animación de la propiedad especificada y detiene la animación. |
| StopAnimationGroup(ICompositionAnimationBase) |
Detiene un grupo de animaciones. |
| TryGetAnimationController(String) |
Devuelve un AnimationController para la animación que se ejecuta en la propiedad especificada. |
Se aplica a
Consulte también
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de