CompositionObject Kelas
Definisi
Penting
Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.
Kelas dasar API komposisi yang mewakili node dalam struktur pohon visual.
Objek komposisi adalah struktur pohon visual tempat semua fitur lain dari API komposisi menggunakan dan membangun. API memungkinkan pengembang untuk menentukan dan membuat satu atau banyak objek Visual yang masing-masing mewakili satu simpul di pohon 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- Warisan
- Turunan
- Atribut
- Penerapan
Persyaratan Windows
| Rangkaian perangkat |
Windows 10 (diperkenalkan dalam 10.0.10240.0)
|
| API contract |
Windows.Foundation.UniversalApiContract (diperkenalkan dalam v1.0)
|
Contoh
Sampel ini menunjukkan bagaimana API komposisi dapat digunakan untuk membuat aplikasi mandiri tanpa menggunakan XAML, WWA, atau DirectX. Sampel menginisialisasi Compositor baru, lalu membuat grafik adegan dengan dua objek 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
Sampel ini menunjukkan cara membangun dan berjalan di pohon Visual sederhana untuk mengubah tingkat keburaman tanpa menggunakan XAML, WWA, atau DirectX. Sampel ini dibangun pada sampel sebelumnya untuk menunjukkan bagaimana Visual anak dibuat, ditambahkan, dan properti diubah.
Dalam skenario ini, hierarki pohon Visual visual dibuat. Setelah Compositor dibuat, itu digunakan untuk membuat objek yang kemudian dapat dikelola.
// 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
Keterangan
Objek dibuat menggunakan objek Compositor . Objek komposisi hanya dapat berupa kontainer atau dapat menyimpan konten. API memungkinkan kemudahan penggunaan dengan menyediakan sekumpulan objek Visual yang jelas untuk tugas tertentu yang ada dalam hierarki:
Visual – objek dasar, sebagian besar properti ada di sini, dan diwarisi oleh objek Visual lainnya.
ContainerVisual – berasal dari Visual, dan menambahkan kemampuan untuk membuat anak-anak.
SpriteVisual – berasal dari ContainerVisual, dan berisi konten dalam bentuk gambar, efek, dan swapchain.
Compositor – mengelola hubungan antara aplikasi dan proses komppositor sistem. Animasi memperbarui properti objek komposisi yang dapat dianimasikan (seperti Visual). Ada dua tipe Animasi:
KeyFrameAnimation: Animasi berbasis waktu dengan dua bingkai kunci atau lebih. Bingkai ini adalah penanda, memungkinkan pengembang untuk menentukan nilai animasi apa yang seharusnya pada waktu yang ditentukan. Animasi juga dapat disempurnakan dengan menentukan bagaimana animasi menginterpolasi (memadukan) nilai di antara bingkai kunci. KeyFrameAnimation memiliki banyak subkelas yang masing-masing mendukung jenis nilai bingkai kunci yang berbeda.
ExpressionAnimation: Animasi yang menggunakan ekspresi matematika untuk menentukan bagaimana nilai animasi harus dihitung setiap bingkai. Ekspresi dapat mereferensikan properti dari objek komposisi. ExpressionAnimationtidak berbasis waktu dan diproses setiap bingkai (jika perlu).
Visual Primitif
Visual Primitif (seperti SpriteVisual) menjelaskan konten visual di layar, dan opsi penyajian yang akan diterapkan ke konten tersebut.
Efek
Efek dapat dilampirkan ke pohon visual untuk menyebabkan perubahan piksel dinamis pada konten sumber, seperti gambar, atau pohon visual.
Efeknya bisa menjadi operasi sederhana seperti desaturasi, operasi yang lebih rumit seperti pengaburan, atau operasi campuran A B yang sangat kompleks seperti memudar silang.
Lihat bagian keterangan dari CompositionEffectBrush untuk informasi tambahan tentang membuat dan menggunakan efek.
Riwayat versi
| Versi Windows | Versi SDK | Nilai ditambahkan |
|---|---|---|
| 1607 | 14393 | Komentar |
| 1607 | 14393 | ImplicitAnimations |
| 1607 | 14393 | StartAnimationGroup |
| 1607 | 14393 | StopAnimationGroup |
| 1709 | 16299 | DispatcherQueue |
| 1803 | 17134 | TryGetAnimationController |
| 1809 | 17763 | PopulatePropertyInfo |
| 1809 | 17763 | StartAnimationGroupWithIAnimationObject |
| 1809 | 17763 | StartAnimationWithIAnimationObject |
Properti
| Comment |
String yang akan dikaitkan dengan CompositionObject. |
| Compositor |
Compositor digunakan untuk membuat CompositionObject ini. |
| Dispatcher |
Dispatcher untuk CompositionObject. |
| DispatcherQueue |
Mendapatkan DispatcherQueue untuk CompostionObject. |
| ImplicitAnimations |
Kumpulan animasi implisit yang melekat pada obyek ini. |
| Properties |
Kumpulan properti yang terkait dengan CompositionObject. |
Metode
| Close() |
Menutup CompositionObject dan merilis sumber daya sistem. |
| ConnectAnimation(String, CompositionAnimation) |
Menyambungkan dan animasi. |
| DisconnectAnimation(String) |
Memutuskan sambungan animasi. |
| Dispose() |
Melakukan tugas yang ditentukan aplikasi yang terkait dengan membebaskan, merilis, atau mengatur ulang sumber daya yang tidak dikelola. |
| PopulatePropertyInfo(String, AnimationPropertyInfo) |
Menentukan properti yang dapat dianimasikan. |
| StartAnimation(String, CompositionAnimation) |
Menyambungkan animasi dengan properti objek yang ditentukan dan memulai animasi. |
| StartAnimation(String, CompositionAnimation, AnimationController) |
Menyambungkan animasi dengan properti objek yang ditentukan dan memulai animasi. |
| StartAnimationGroup(ICompositionAnimationBase) |
Memulai grup animasi. Metode StartAnimationGroup pada CompositionObject memungkinkan Anda memulai CompositionAnimationGroup. Semua animasi dalam grup akan dimulai pada saat yang sama pada objek. |
| StartAnimationGroupWithIAnimationObject(IAnimationObject, ICompositionAnimationBase) |
Memulai grup animasi pada target yang ditentukan. |
| StartAnimationWithIAnimationObject(IAnimationObject, String, CompositionAnimation) |
Menyambungkan animasi dengan properti objek target yang ditentukan dan memulai animasi. |
| StopAnimation(String) |
Memutuskan sambungan animasi dari properti yang ditentukan dan menghentikan animasi. |
| StopAnimationGroup(ICompositionAnimationBase) |
Menghentikan grup animasi. |
| TryGetAnimationController(String) |
Mengembalikan AnimationController untuk animasi yang berjalan pada properti yang ditentukan. |
Berlaku untuk
Lihat juga
Saran dan Komentar
Segera hadir: Sepanjang tahun 2024 kami akan menghentikan penggunaan GitHub Issues sebagai mekanisme umpan balik untuk konten dan menggantinya dengan sistem umpan balik baru. Untuk mengetahui informasi selengkapnya, lihat: https://aka.ms/ContentUserFeedback.
Kirim dan lihat umpan balik untuk