CompositionObject Classe

Riferimento

Definizione

Spazio dei nomi:: Windows.UI.Composition

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Modifica

Classe di base dell'API di composizione che rappresenta un nodo nella struttura ad albero visuale.

Gli oggetti composition sono la struttura ad albero visuale su cui vengono usate e compilate tutte le altre funzionalità dell'API di composizione. L’API permette agli sviluppatori di definire e creare uno o più oggetti Visual, ognuno dei quali rappresenta un singolo nodo in una struttura ad albero visuale.

[WebHostHidden]
public ref class CompositionObject : IClosable

public ref class CompositionObject : IClosable

public 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, IAnimationObject

Public Class CompositionObject
Implements IDisposable

Public Class CompositionObject
Implements IAnimationObject, IDisposable

Ereditarietà: Object Platform::Object IInspectable CompositionObject

Derivato: Windows.UI.Composition.AnimationController

Windows.UI.Composition.AnimationEndedEventArgs

Windows.UI.Composition.AnimationPropertyInfo

Windows.UI.Composition.CompositionAnimation

Windows.UI.Composition.CompositionAnimationGroup

Altro…

Attributi: ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Implementazioni: IClosable IDisposable IAnimationObject

Requisiti Windows

Famiglia di dispositivi	Windows 10 (è stato introdotto in 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (è stato introdotto in v1.0)

Esempio

Questo esempio mostra come usare l'API di composizione per creare un'app autonoma senza usare XAML, WWA o DirectX. L'esempio inizializza un nuovo compositore e quindi crea un grafico della scena con due oggetti 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

Questo esempio illustra come costruire e camminare su un albero semplice di oggetti visivi per modificare l'opacità senza usare XAML, WWA o DirectX. Questo esempio si basa sull'esempio precedente per mostrare come vengono creati, aggiunti e modificati gli oggetti visivi figlio.

In questo scenario viene compilata una gerarchia albero visuale di Oggetti visivi. Dopo aver creato un compositor, viene usato per creare oggetti che possono essere gestiti.

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

Commenti

Gli oggetti vengono creati usando un oggetto Compositor . Gli oggetti di composizione possono essere solo contenitori o possono contenere contenuto. L’API consente la facilità d’uso fornendo un chiaro set di Visual oggetti per attività specifiche che esistono in una gerarchia:

Visual – Oggetto di base. Questo oggetto include la maggior parte delle proprietà ereditate dagli altri oggetti visivi.
ContainerVisual – Deriva da Visual e aggiunge la possibilità di creare oggetti figlio.
SpriteVisual : deriva da ContainerVisual e contiene contenuto sotto forma di immagini, effetti e swapchain.
Compositor : gestisce la relazione tra un'applicazione e il processo di composizione del sistema. Le animazioni aggiornano le proprietà di qualsiasi oggetto composizione animabile, ad esempio Visual. Esistono due tipi di animazioni:
KeyFrameAnimation: animazioni basate sul tempo con due o più fotogrammi chiave. Questi fotogrammi sono marcatori, consentendo agli sviluppatori di definire il valore animato nel momento specificato. Le animazioni possono inoltre essere ottimizzate specificando come l'animazione interpola (combina) i valori tra fotogrammi chiave. KeyFrameAnimation include molte sottoclassi che supportano un tipo diverso di valore del fotogramma chiave.
ExpressionAnimation: animazioni che usano un'espressione matematica per specificare la modalità di calcolo del valore animato per ogni fotogramma. Le espressioni possono fare riferimento a proprietà da oggetti di composizione. ExpressionAnimations non è basato sul tempo e viene elaborato ogni frame (se necessario).

Oggetti visivi primitivi

Gli oggetti visivi primitivi (ad esempio SpriteVisual) descrivono il contenuto visivo sullo schermo e le opzioni di rendering che verranno applicate a tale contenuto.

Effetti

Gli effetti possono essere associati alla struttura ad albero visuale per causare modifiche di pixel dinamici al contenuto di origine, ad esempio immagini o alberi di oggetti visivi.

Un effetto può essere operazioni semplici, ad esempio una desatura, operazioni più complesse, ad esempio sfocatura o operazioni di fusione A B molto complesse, ad esempio dissolvenze incrociate.

Per altre informazioni sulla creazione e sull'uso degli effetti, vedere la sezione osservazioni di CompositionEffectBrush .

Cronologia delle versioni

Versione di Windows	Versione dell'SDK	Valore aggiunto
1607	14393	Commento
1607	14393	ImplicitAnimations
1607	14393	StartAnimationGroup
1607	14393	StopAnimationGroup
1709	16299	DispatcherQueue
1803	17134	TryGetAnimationController
1809	17763	PopulatePropertyInfo
1809	17763	StartAnimationGroupWithIAnimationObject
1809	17763	StartAnimationWithIAnimationObject

Proprietà

Comment	Stringa da associare a CompositionObject.
Compositor	Compositore usato per creare questo oggetto CompositionObject.
Dispatcher	Dispatcher per CompositionObject.
DispatcherQueue	Ottiene dispatcherQueue per CompostionObject.
ImplicitAnimations	Raccolta di animazioni implicite associate a questo oggetto.
Properties	Raccolta di proprietà associate a CompositionObject.

Metodi

Close()	Chiude l'oggetto CompositionObject e rilascia le risorse di sistema.
ConnectAnimation(String, CompositionAnimation)	Connette e animazione.
DisconnectAnimation(String)	Disconnette un'animazione.
Dispose()	Esegue attività definite dall'applicazione, come rilasciare o reimpostare risorse non gestite.
PopulatePropertyInfo(String, AnimationPropertyInfo)	Definisce una proprietà che può essere animata.
StartAnimation(String, CompositionAnimation, AnimationController)	Connette un'animazione con la proprietà specificata dell'oggetto e avvia l'animazione.
StartAnimation(String, CompositionAnimation)	Connette un'animazione con la proprietà specificata dell'oggetto e avvia l'animazione.
StartAnimationGroup(ICompositionAnimationBase)	Avvia un gruppo di animazioni. Il metodo StartAnimationGroup in CompositionObject consente di avviare CompositionAnimationGroup. Tutte le animazioni del gruppo verranno avviate contemporaneamente sull'oggetto.
StartAnimationGroupWithIAnimationObject(IAnimationObject, ICompositionAnimationBase)	Avvia un gruppo di animazioni nella destinazione specificata.
StartAnimationWithIAnimationObject(IAnimationObject, String, CompositionAnimation)	Connette un'animazione con la proprietà specificata dell'oggetto di destinazione e avvia l'animazione.
StopAnimation(String)	Disconnette un'animazione dalla proprietà specificata e arresta l'animazione.
StopAnimationGroup(ICompositionAnimationBase)	Arresta un gruppo di animazioni.
TryGetAnimationController(String)	Restituisce un oggetto AnimationController per l'animazione in esecuzione nella proprietà specificata.

Si applica a

Vedi anche

IClosable

Condividi tramite