De visuallaag gebruiken met Windows Forms

U kunt Windows Runtime Compositie-API's (ook wel de Visual layer genoemd) gebruiken in uw Windows Forms-apps om moderne ervaringen te creëren die Windows-gebruikers aanspreken.

De volledige code voor deze zelfstudie is beschikbaar op GitHub: Windows Forms HelloComposition-voorbeeld.

Prerequisites

De UWP-hosting-API heeft deze vereisten.

We gaan ervan uit dat u bekend bent met app-ontwikkeling met behulp van Windows Forms en UWP. Zie voor meer informatie:
.NET Framework 4.7.2 of hoger
Windows 10 versie 1803 of hoger
Windows 10 SDK 17134 of hoger

Samenstellings-API's gebruiken in Windows Forms

In deze zelfstudie maakt u een eenvoudige Windows Forms ui en voegt u er geanimeerde samenstellingselementen aan toe. Zowel de Windows Forms als de samenstellingsonderdelen worden eenvoudig gehouden, maar de getoonde interoperabiliteitscode is hetzelfde, ongeacht de complexiteit van de onderdelen. De voltooide app ziet er als volgt uit.

de gebruikersinterface van de actieve app

Een Windows Forms-project maken

De eerste stap is het maken van het Windows Forms app-project, dat een toepassingsdefinitie en het hoofdformulier voor de gebruikersinterface bevat.

Een nieuw Windows Forms toepassingsproject maken in Visual C# met de naam HelloComposition:

Open Visual Studio en vervolgens selecteer Bestand>Nieuw>Project.
Het dialoogvenster Nieuw project wordt geopend.
Vouw onder de categorie Installed het knooppunt Visual C# uit en selecteer Windows Desktop.
Selecteer de sjabloon Windows Forms App (.NET Framework).
Voer de naam HelloComposition, selecteer Framework .NET Framework 4.7.2 en klik vervolgens op OK.

Visual Studio maakt het project en opent u de ontwerpfunctie voor het standaardtoepassingsvenster met de naam Form1.cs.

Het project configureren voor het gebruik van Windows Runtime-API's

Als u Windows Runtime (WinRT)-API's in uw Windows Forms-app wilt gebruiken, moet u uw Visual Studio project configureren voor toegang tot de Windows Runtime. Bovendien worden vectoren uitgebreid gebruikt door de Samenstelling-API's, dus u moet de verwijzingen toevoegen die nodig zijn om vectoren te gebruiken.

NuGet-pakketten zijn beschikbaar om aan beide behoeften te voldoen. Installeer de nieuwste versies van deze pakketten om de benodigde verwijzingen aan uw project toe te voegen.

Microsoft.Windows. SDK. Contracten (vereist standaardindeling voor pakketbeheer ingesteld op PackageReference.)
System.Numerics.Vectors

Note

We raden u aan de NuGet-pakketten te gebruiken om uw project te configureren, maar u kunt de vereiste verwijzingen handmatig toevoegen. Zie Optimaliseer uw bureaubladtoepassing voor Windows voor meer informatie. In de volgende tabel ziet u de bestanden waaraan u verwijzingen moet toevoegen.

File	Locatie
System.Runtime.WindowsRuntime	C:\Windows\Microsoft.NET\Framework\v4.0.30319
Windows.Foundation.UniversalApiContract.winmd	C:\Program Files (x86)\Windows Kits\10\References<sdk version>\Windows.Foundation.UniversalApiContract<version>
Windows.Foundation.FoundationContract.winmd	C:\Program Files (x86)\Windows Kits\10\References<sdk version>\Windows. Foundation.FoundationContract<version>
System.Numerics.Vectors.dll	C:\WINDOWS\Microsoft.Net\assembly\GAC_MSIL\System.Numerics.Vectors\v4.0_4.0.0.0__b03f5f7f11d50a3a
System.Numerics.dll	C:\Program Files (x86)\Reference Assembly's\Microsoft\Framework.NETFramework\v4.7.2

Een aangepaste controle maken voor het beheren van interop

Als u inhoud wilt hosten die u hebt gemaakt met de visuele laag, maakt u een aangepast besturingselement afgeleid van Control. Met dit besturingselement hebt u toegang tot een venstergreep die u nodig hebt om de container voor de inhoud van uw visuele laag te maken.

Hier doet u het grootste deel van de configuratie voor het hosten van Samenstelling-API's. In dit besturingselement gebruikt u PlatformInvocation Services (PInvoke) en COM Interop om Samenstelling-API's in uw Windows Forms-app te brengen. Zie Interopereren met unmanaged code voor meer informatie over PInvoke en COM Interop.

Tip

Als dat nodig is, controleert u de volledige code aan het einde van de zelfstudie om ervoor te zorgen dat alle code zich op de juiste plaatsen bevindt terwijl u de zelfstudie doorloopt.

Voeg een nieuw aangepast besturingselementbestand toe aan uw project dat is afgeleid van Control.
- Klik in Solution Explorer-met de rechtermuisknop op het project HelloComposition.
- SelecteerNieuw item> in het contextmenu....
- Selecteer Aangepast besturingselement in het dialoogvenster Nieuw item toevoegen.
- Geef het besturingselement een naam CompositionHost.cs en klik vervolgens op Toevoegen. CompositionHost.cs wordt geopend in de ontwerpweergave.

Schakel over naar de codeweergave voor CompositionHost.cs en voeg de volgende code toe aan de klasse.

// Add
// using Windows.UI.Composition;

IntPtr hwndHost;
object dispatcherQueue;
protected ContainerVisual containerVisual;
protected Compositor compositor;

private ICompositionTarget compositionTarget;

public Visual Child
{
    set
    {
        if (compositor == null)
        {
            InitComposition(hwndHost);
        }
        compositionTarget.Root = value;
    }
}

Voeg code toe aan de constructor.

In de constructor roept u de methoden InitializeCoreDispatcher en InitComposition aan. U maakt deze methoden in de volgende stappen.

public CompositionHost()
{
    InitializeComponent();

    // Get the window handle.
    hwndHost = Handle;

    // Create dispatcher queue.
    dispatcherQueue = InitializeCoreDispatcher();

    // Build Composition tree of content.
    InitComposition(hwndHost);
}

Initialiseer een thread met een CoreDispatcher. De kernverzender is verantwoordelijk voor het verwerken van vensterberichten en verzendingsgebeurtenissen voor WinRT-API's. Nieuwe exemplaren van Compositor moeten worden gemaakt op een thread met een CoreDispatcher.

Maak een methode met de naam InitializeCoreDispatcher en voeg code toe om de dispatcherwachtrij in te stellen.

// Add
// using System.Runtime.InteropServices;

private object InitializeCoreDispatcher()
{
    DispatcherQueueOptions options = new DispatcherQueueOptions();
    options.apartmentType = DISPATCHERQUEUE_THREAD_APARTMENTTYPE.DQTAT_COM_STA;
    options.threadType = DISPATCHERQUEUE_THREAD_TYPE.DQTYPE_THREAD_CURRENT;
    options.dwSize = Marshal.SizeOf(typeof(DispatcherQueueOptions));

    object queue = null;
    CreateDispatcherQueueController(options, out queue);
    return queue;
}

Voor de dispatcherwachtrij is een PInvoke-declaratie vereist. Plaats deze declaratie aan het einde van de code voor de klasse. (We plaatsen deze code in een regio om de klassecode netjes te houden.)

#region PInvoke declarations

//typedef enum DISPATCHERQUEUE_THREAD_APARTMENTTYPE
//{
//    DQTAT_COM_NONE,
//    DQTAT_COM_ASTA,
//    DQTAT_COM_STA
//};
internal enum DISPATCHERQUEUE_THREAD_APARTMENTTYPE
{
    DQTAT_COM_NONE = 0,
    DQTAT_COM_ASTA = 1,
    DQTAT_COM_STA = 2
};

//typedef enum DISPATCHERQUEUE_THREAD_TYPE
//{
//    DQTYPE_THREAD_DEDICATED,
//    DQTYPE_THREAD_CURRENT
//};
internal enum DISPATCHERQUEUE_THREAD_TYPE
{
    DQTYPE_THREAD_DEDICATED = 1,
    DQTYPE_THREAD_CURRENT = 2,
};

//struct DispatcherQueueOptions
//{
//    DWORD dwSize;
//    DISPATCHERQUEUE_THREAD_TYPE threadType;
//    DISPATCHERQUEUE_THREAD_APARTMENTTYPE apartmentType;
//};
[StructLayout(LayoutKind.Sequential)]
internal struct DispatcherQueueOptions
{
    public int dwSize;

    [MarshalAs(UnmanagedType.I4)]
    public DISPATCHERQUEUE_THREAD_TYPE threadType;

    [MarshalAs(UnmanagedType.I4)]
    public DISPATCHERQUEUE_THREAD_APARTMENTTYPE apartmentType;
};

//HRESULT CreateDispatcherQueueController(
//  DispatcherQueueOptions options,
//  ABI::Windows::System::IDispatcherQueueController** dispatcherQueueController
//);
[DllImport("coremessaging.dll", EntryPoint = "CreateDispatcherQueueController", CharSet = CharSet.Unicode)]
internal static extern IntPtr CreateDispatcherQueueController(DispatcherQueueOptions options,
                                        [MarshalAs(UnmanagedType.IUnknown)]
                                        out object dispatcherQueueController);

#endregion PInvoke declarations

U hebt nu de wachtrij voor de dispatcher klaar en kunt beginnen met het initialiseren en creëren van Composition-inhoud.

Initialiseer de Compositor. De compositor is een fabriek die een verscheidenheid aan typen creëert in de Windows. UI. Samenstelling naamruimte die de visuele laag, het effectensysteem en het animatiesysteem beslaat. De Compositor-klasse beheert ook de levensduur van objecten die zijn gemaakt door de factory class.

private void InitComposition(IntPtr hwndHost)
{
    ICompositorDesktopInterop interop;

    compositor = new Compositor();
    object iunknown = compositor as object;
    interop = (ICompositorDesktopInterop)iunknown;
    IntPtr raw;
    interop.CreateDesktopWindowTarget(hwndHost, true, out raw);

    object rawObject = Marshal.GetObjectForIUnknown(raw);
    compositionTarget = (ICompositionTarget)rawObject;

    if (raw == null) { throw new Exception("QI Failed"); }

    containerVisual = compositor.CreateContainerVisual();
    Child = containerVisual;
}

ICompositorDesktopInterop en ICompositionTarget vereisen COM-import. Plaats deze code na de CompositionHost-klasse , maar in de naamruimtedeclaratie.

#region COM Interop

/*
#undef INTERFACE
#define INTERFACE ICompositorDesktopInterop
    DECLARE_INTERFACE_IID_(ICompositorDesktopInterop, IUnknown, "29E691FA-4567-4DCA-B319-D0F207EB6807")
    {
        IFACEMETHOD(CreateDesktopWindowTarget)(
            _In_ HWND hwndTarget,
            _In_ BOOL isTopmost,
            _COM_Outptr_ IDesktopWindowTarget * *result
            ) PURE;
    };
*/
[ComImport]
[Guid("29E691FA-4567-4DCA-B319-D0F207EB6807")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface ICompositorDesktopInterop
{
    void CreateDesktopWindowTarget(IntPtr hwndTarget, bool isTopmost, out IntPtr test);
}

//[contract(Windows.Foundation.UniversalApiContract, 2.0)]
//[exclusiveto(Windows.UI.Composition.CompositionTarget)]
//[uuid(A1BEA8BA - D726 - 4663 - 8129 - 6B5E7927FFA6)]
//interface ICompositionTarget : IInspectable
//{
//    [propget] HRESULT Root([out] [retval] Windows.UI.Composition.Visual** value);
//    [propput] HRESULT Root([in] Windows.UI.Composition.Visual* value);
//}

[ComImport]
[Guid("A1BEA8BA-D726-4663-8129-6B5E7927FFA6")]
[InterfaceType(ComInterfaceType.InterfaceIsIInspectable)]
public interface ICompositionTarget
{
    Windows.UI.Composition.Visual Root
    {
        get;
        set;
    }
}

#endregion COM Interop

Een aangepast besturingselement maken voor het hosten van samenstellingselementen

Het is een goed idee om de code te plaatsen die uw samenstellingselementen genereert en beheert in een afzonderlijk besturingselement dat is afgeleid van CompositionHost. Hierdoor blijft de interop-code die u in de CompositionHost-klasse hebt gemaakt, herbruikbaar.

Hier maakt u een aangepast besturingselement dat is afgeleid van CompositionHost. Dit besturingselement wordt toegevoegd aan de Visual Studio werkset, zodat u dit aan uw formulier kunt toevoegen.

Voeg een nieuw aangepast besturingsbestand toe aan uw project dat is afgeleid van CompositionHost.
- Klik in Solution Explorer-met de rechtermuisknop op het project HelloComposition.
- SelecteerNieuw item> in het contextmenu....
- Selecteer Aangepast besturingselement in het dialoogvenster Nieuw item toevoegen.
- Geef het besturingselement een naam CompositionHostControl.cs en klik vervolgens op Toevoegen. CompositionHostControl.cs wordt geopend in de ontwerpweergave.
Stel in het deelvenster Eigenschappen voor CompositionHostControl.cs ontwerpweergave de eigenschap BackColor in op ControlLight.

Het instellen van de achtergrondkleur is optioneel. We doen het hier zodat u uw aangepaste bedieningselement tegen de achtergrond van het formulier kunt zien.
Schakel over naar de codeweergave voor CompositionHostControl.cs en werk de klassedeclaratie bij om af te leiden van CompositionHost.
```
class CompositionHostControl : CompositionHost
```
Werk de constructor bij zodat de basisconstructor wordt aangeroepen.
```
public CompositionHostControl() : base()
{

}
```

Samenstellingselementen toevoegen

Nu de infrastructuur is geïmplementeerd, kunt u samenstellingsinhoud toevoegen aan de gebruikersinterface van de app.

In dit voorbeeld voegt u code toe aan de klasse CompositionHostControl waarmee u een eenvoudige SpriteVisual maakt en er animatie aan toevoegt.

Voeg een samenstellingselement toe.

Voeg in CompositionHostControl.cs deze methoden toe aan de klasse CompositionHostControl.

// Add
// using Windows.UI.Composition;

public void AddElement(float size, float offsetX, float offsetY)
{
    var visual = compositor.CreateSpriteVisual();
    visual.Size = new Vector2(size, size); // Requires references
    visual.Brush = compositor.CreateColorBrush(GetRandomColor());
    visual.Offset = new Vector3(offsetX, offsetY, 0);
    containerVisual.Children.InsertAtTop(visual);

    AnimateSquare(visual, 3);
}

private void AnimateSquare(SpriteVisual visual, int delay)
{
    float offsetX = (float)(visual.Offset.X);
    Vector3KeyFrameAnimation animation = compositor.CreateVector3KeyFrameAnimation();
    float bottom = Height - visual.Size.Y;
    animation.InsertKeyFrame(1f, new Vector3(offsetX, bottom, 0f));
    animation.Duration = TimeSpan.FromSeconds(2);
    animation.DelayTime = TimeSpan.FromSeconds(delay);
    visual.StartAnimation("Offset", animation);
}

private Windows.UI.Color GetRandomColor()
{
    Random random = new Random();
    byte r = (byte)random.Next(0, 255);
    byte g = (byte)random.Next(0, 255);
    byte b = (byte)random.Next(0, 255);
    return Windows.UI.Color.FromArgb(255, r, g, b);
}

Voeg het controle-element toe aan uw formulier

Nu u een aangepast besturingselement hebt voor het hosten van samenstellingsinhoud, kunt u dit toevoegen aan de gebruikersinterface van de app. Hier voegt u een exemplaar toe van de CompositionHostControl die u in de vorige stap hebt gemaakt. CompositionHostControl wordt automatisch toegevoegd aan de Visual Studio werkset onder projectnaam Components.

Voeg in Form1.CS ontwerpweergave een knop toe aan de gebruikersinterface.
- Sleep een Button van de gereedschapskist naar Form1. Plaats deze in de linkerbovenhoek van het formulier. (Zie de afbeelding aan het begin van de zelfstudie om de plaatsing van de besturingselementen te controleren.)
- Wijzig in het deelvenster Eigenschappen de eigenschap Tekst van button1 in Samenstellingselement toevoegen.
- Pas het formaat van de knop aan zodat alle tekst wordt weergegeven.
(Zie voor meer informatie Hoe u: Besturingselementen toevoegen aan Windows Forms.)
Voeg een CompositionHostControl toe aan de gebruikersinterface.
- Sleep een CompositionHostControl van de toolbox naar Form1. Plaats deze rechts van de knop.
- Wijzig de grootte van de CompositionHost zodat de rest van het formulier wordt ingevuld.
Behandel de gebeurtenis van de knopklik.
- Klik in het deelvenster Eigenschappen op het bliksemschichticoon om over te schakelen naar de weergave Gebeurtenissen.
- Selecteer in de lijst met gebeurtenissen de gebeurtenis Klikken , typ Button_Click en druk op Enter.
- Deze code wordt toegevoegd in Form1.cs:
```
private void Button_Click(object sender, EventArgs e)
{

}
```
Voeg code toe aan de knop klikhandler om nieuwe elementen te maken.
- Voeg in Form1.cs code toe aan de Button_Click gebeurtenis-handler die u eerder hebt gemaakt. Deze code roept CompositionHostControl1.AddElement aan om een nieuw element te maken met een willekeurig gegenereerde grootte en offset. (Het exemplaar van CompositionHostControl heette automatisch compositionHostControl1 toen u het naar het formulier sleepte.)
```
// Add
// using System;

private void Button_Click(object sender, RoutedEventArgs e)
{
    Random random = new Random();
    float size = random.Next(50, 150);
    float offsetX = random.Next(0, (int)(compositionHostControl1.Width - size));
    float offsetY = random.Next(0, (int)(compositionHostControl1.Height/2 - size));
    compositionHostControl1.AddElement(size, offsetX, offsetY);
}
```

U kunt nu uw Windows Forms-app bouwen en uitvoeren. Wanneer u op de knop klikt, ziet u geanimeerde vierkantjes die zijn toegevoegd aan de gebruikersinterface.

Volgende stappen

Voor een completer voorbeeld dat voortbouwt op dezelfde infrastructuur, zie het Windows Forms-visuallagenintegratievoorbeeld op GitHub.

Aanvullende bronnen

Getting Started with Windows Forms (.NET)
Interoperatie met niet-beheerde code (.NET)
Aan de slag met Windows-apps (UWP)
Uw bureaubladtoepassing verbeteren voor Windows (UWP)
Windows.UI.Composition-naamruimte (UWP)

De volledige code

Hier volgt de volledige code voor deze zelfstudie.

Form1.cs

using System;
using System.Windows.Forms;

namespace HelloComposition
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, EventArgs e)
        {
            Random random = new Random();
            float size = random.Next(50, 150);
            float offsetX = random.Next(0, (int)(compositionHostControl1.Width - size));
            float offsetY = random.Next(0, (int)(compositionHostControl1.Height/2 - size));
            compositionHostControl1.AddElement(size, offsetX, offsetY);
        }
    }
}

CompositionHostControl.cs

using System;
using System.Numerics;
using Windows.UI.Composition;

namespace HelloComposition
{
    class CompositionHostControl : CompositionHost
    {
        public CompositionHostControl() : base()
        {

        }

        public void AddElement(float size, float offsetX, float offsetY)
        {
            var visual = compositor.CreateSpriteVisual();
            visual.Size = new Vector2(size, size); // Requires references
            visual.Brush = compositor.CreateColorBrush(GetRandomColor());
            visual.Offset = new Vector3(offsetX, offsetY, 0);
            containerVisual.Children.InsertAtTop(visual);

            AnimateSquare(visual, 3);
        }

        private void AnimateSquare(SpriteVisual visual, int delay)
        {
            float offsetX = (float)(visual.Offset.X);
            Vector3KeyFrameAnimation animation = compositor.CreateVector3KeyFrameAnimation();
            float bottom = Height - visual.Size.Y;
            animation.InsertKeyFrame(1f, new Vector3(offsetX, bottom, 0f));
            animation.Duration = TimeSpan.FromSeconds(2);
            animation.DelayTime = TimeSpan.FromSeconds(delay);
            visual.StartAnimation("Offset", animation);
        }

        private Windows.UI.Color GetRandomColor()
        {
            Random random = new Random();
            byte r = (byte)random.Next(0, 255);
            byte g = (byte)random.Next(0, 255);
            byte b = (byte)random.Next(0, 255);
            return Windows.UI.Color.FromArgb(255, r, g, b);
        }
    }
}

CompositionHost.cs

using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using Windows.UI.Composition;

namespace HelloComposition
{
    public partial class CompositionHost : Control
    {
        IntPtr hwndHost;
        object dispatcherQueue;
        protected ContainerVisual containerVisual;
        protected Compositor compositor;
        private ICompositionTarget compositionTarget;

        public Visual Child
        {
            set
            {
                if (compositor == null)
                {
                    InitComposition(hwndHost);
                }
                compositionTarget.Root = value;
            }
        }

        public CompositionHost()
        {
            // Get the window handle.
            hwndHost = Handle;

            // Create dispatcher queue.
            dispatcherQueue = InitializeCoreDispatcher();

            // Build Composition tree of content.
            InitComposition(hwndHost);
        }

        private object InitializeCoreDispatcher()
        {
            DispatcherQueueOptions options = new DispatcherQueueOptions();
            options.apartmentType = DISPATCHERQUEUE_THREAD_APARTMENTTYPE.DQTAT_COM_STA;
            options.threadType = DISPATCHERQUEUE_THREAD_TYPE.DQTYPE_THREAD_CURRENT;
            options.dwSize = Marshal.SizeOf(typeof(DispatcherQueueOptions));

            object queue = null;
            CreateDispatcherQueueController(options, out queue);
            return queue;
        }

        private void InitComposition(IntPtr hwndHost)
        {
            ICompositorDesktopInterop interop;

            compositor = new Compositor();
            object iunknown = compositor as object;
            interop = (ICompositorDesktopInterop)iunknown;
            IntPtr raw;
            interop.CreateDesktopWindowTarget(hwndHost, true, out raw);

            object rawObject = Marshal.GetObjectForIUnknown(raw);
            compositionTarget = (ICompositionTarget)rawObject;

            if (raw == null) { throw new Exception("QI Failed"); }

            containerVisual = compositor.CreateContainerVisual();
            Child = containerVisual;
        }

        protected override void OnPaint(PaintEventArgs pe)
        {
            base.OnPaint(pe);
        }

        #region PInvoke declarations

        //typedef enum DISPATCHERQUEUE_THREAD_APARTMENTTYPE
        //{
        //    DQTAT_COM_NONE,
        //    DQTAT_COM_ASTA,
        //    DQTAT_COM_STA
        //};
        internal enum DISPATCHERQUEUE_THREAD_APARTMENTTYPE
        {
            DQTAT_COM_NONE = 0,
            DQTAT_COM_ASTA = 1,
            DQTAT_COM_STA = 2
        };

        //typedef enum DISPATCHERQUEUE_THREAD_TYPE
        //{
        //    DQTYPE_THREAD_DEDICATED,
        //    DQTYPE_THREAD_CURRENT
        //};
        internal enum DISPATCHERQUEUE_THREAD_TYPE
        {
            DQTYPE_THREAD_DEDICATED = 1,
            DQTYPE_THREAD_CURRENT = 2,
        };

        //struct DispatcherQueueOptions
        //{
        //    DWORD dwSize;
        //    DISPATCHERQUEUE_THREAD_TYPE threadType;
        //    DISPATCHERQUEUE_THREAD_APARTMENTTYPE apartmentType;
        //};
        [StructLayout(LayoutKind.Sequential)]
        internal struct DispatcherQueueOptions
        {
            public int dwSize;

            [MarshalAs(UnmanagedType.I4)]
            public DISPATCHERQUEUE_THREAD_TYPE threadType;

            [MarshalAs(UnmanagedType.I4)]
            public DISPATCHERQUEUE_THREAD_APARTMENTTYPE apartmentType;
        };

        //HRESULT CreateDispatcherQueueController(
        //  DispatcherQueueOptions options,
        //  ABI::Windows::System::IDispatcherQueueController** dispatcherQueueController
        //);
        [DllImport("coremessaging.dll", EntryPoint = "CreateDispatcherQueueController", CharSet = CharSet.Unicode)]
        internal static extern IntPtr CreateDispatcherQueueController(DispatcherQueueOptions options,
                                                 [MarshalAs(UnmanagedType.IUnknown)]
                                        out object dispatcherQueueController);

        #endregion PInvoke declarations
    }

    #region COM Interop

    /*
    #undef INTERFACE
    #define INTERFACE ICompositorDesktopInterop
        DECLARE_INTERFACE_IID_(ICompositorDesktopInterop, IUnknown, "29E691FA-4567-4DCA-B319-D0F207EB6807")
        {
            IFACEMETHOD(CreateDesktopWindowTarget)(
                _In_ HWND hwndTarget,
                _In_ BOOL isTopmost,
                _COM_Outptr_ IDesktopWindowTarget * *result
                ) PURE;
        };
    */
    [ComImport]
    [Guid("29E691FA-4567-4DCA-B319-D0F207EB6807")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface ICompositorDesktopInterop
    {
        void CreateDesktopWindowTarget(IntPtr hwndTarget, bool isTopmost, out IntPtr test);
    }

    //[contract(Windows.Foundation.UniversalApiContract, 2.0)]
    //[exclusiveto(Windows.UI.Composition.CompositionTarget)]
    //[uuid(A1BEA8BA - D726 - 4663 - 8129 - 6B5E7927FFA6)]
    //interface ICompositionTarget : IInspectable
    //{
    //    [propget] HRESULT Root([out] [retval] Windows.UI.Composition.Visual** value);
    //    [propput] HRESULT Root([in] Windows.UI.Composition.Visual* value);
    //}

    [ComImport]
    [Guid("A1BEA8BA-D726-4663-8129-6B5E7927FFA6")]
    [InterfaceType(ComInterfaceType.InterfaceIsIInspectable)]
    public interface ICompositionTarget
    {
        Windows.UI.Composition.Visual Root
        {
            get;
            set;
        }
    }
    #endregion COM Interop
}

Feedback

Is deze pagina nuttig?

Last updated on 2026-05-02