Tag Archives: Windows 10 Creators Update

Windows 10 Tip: How to use Surface Dial with Paint 3D

Whether you’re an artist, student or mobile professional, Surface Dial optimizes your digital workflow by bringing your most-used shortcuts and tools to your screen with simple presses and turns of the Dial. You can also use Dial to do things like play music or skip tracks in Groove Music, scroll through web pages in Microsoft Edge, scroll through documents in Microsoft Word off-screen, and so much more.

Today, we’re going to show you a couple ways you can get started using your Surface Dial with the Paint 3D app in Windows 10.* If you have the new Surface Pro or the Surface Studio, you can use the Dial with Paint 3D directly on your screen.**

Set-up

Make sure you have the Surface Dial connected via Bluetooth to your device. You should be able to press and hold the dial to see a context menu pop-up. Open the Paint 3D app to get started and make sure you are in the Paint 3D app when you are using the Surface Dial to access the features below. The dial will have haptic feedback as you use different features in Paint 3D.

Change the color easily using the color wheel

Change the color easily using the color wheel

It’s super simple to change brush colors. On the Surface Studio, press down on the Surface Dial to select the color palette and the color wheel will pop-up. Turn the Dial and the dot will move to show you what color you have selected. Press down to select the color.

On a Surface Pro device, press down on the Surface Dial to select the color palette. Turn the dial and the color selection in your tool bar will move to the right and left. Press down to select the color.

Be playful as you adjust colors & brushes

There’s no need to stop painting just to change the color or brush thickness. Create seamless tapered strokes by turning the Surface Dial to adjust color, brush thickness, and opacity while drawing.

Click on the art tools button, and select a brush.

Click on the art tools button, and select a brush. To change colors dynamically, press down on the dial and select color palette. Use your pen to draw and turn the dial simultaneously to instantly change from one color to the next. To change the thickness, press down on the dial and choose thickness on the context menu. Press down to select.  Turn the dial to the left to taper the line smaller and to the right to make the line thicker.

Rotate objects while painting

Click on the art tools button and choose a brush and color.

The Surface Dial makes it easy to rotate as you paint. Using your digital pen, use the 3D tools to draw a 3D object or pull a model from the Remix 3D community. Click on the art tools button and choose a brush and color. Start painting on your 3D model and keep your pen stationary while turning the dial to rotate the object underneath.

Hit undo

Press and hold for the context menu, and scroll to the last button, undo.

Don’t be afraid to experiment with easy access to the undo button on the Surface Dial. Press and hold for the context menu, and scroll to the last button, undo. Press down on the dial to select and turn the dial to roll-back any changes you’ve made.

Stamping and stickers

Click on the Stickers Tool and select a pre-made sticker, or upload your own.

Click on the Stickers Tool and select a pre-made sticker, or upload your own. Choose where to position the sticker 3D model and simply press down on the Dial to stamp the sticker onto the 3D object. It’s super fun and easy.

If you don’t have a Surface Dial yet, you can order one here from the Microsoft Store. Head over here for five things you need to know about Surface Dial, or check out tips on getting started using Paint 3D.

In case you missed it, here’s last week’s Windows 10 Tip:

<!–
!function(a,b){“use strict”;function c(){if(!e){e=!0;var a,c,d,f,g=-1!==navigator.appVersion.indexOf(“MSIE 10”),h=!!navigator.userAgent.match(/Trident.*rv:11./),i=b.querySelectorAll(“iframe.wp-embedded-content”);for(c=0;c<i.length;c++){if(d=i[c],!d.getAttribute(“data-secret”))f=Math.random().toString(36).substr(2,10),d.src+=”#?secret=”+f,d.setAttribute(“data-secret”,f);if(g||h)a=d.cloneNode(!0),a.removeAttribute(“security”),d.parentNode.replaceChild(a,d)}}}var d=!1,e=!1;if(b.querySelector)if(a.addEventListener)d=!0;if(a.wp=a.wp||{},!a.wp.receiveEmbedMessage)if(a.wp.receiveEmbedMessage=function(c){var d=c.data;if(d.secret||d.message||d.value)if(!/[^a-zA-Z0-9]/.test(d.secret)){var e,f,g,h,i,j=b.querySelectorAll(‘iframe[data-secret=”‘+d.secret+'”]’),k=b.querySelectorAll(‘blockquote[data-secret=”‘+d.secret+'”]’);for(e=0;e<k.length;e++)k[e].style.display=”none”;for(e=0;e1e3)g=1e3;else if(~~g<!]]>

Have a great week!

*Surface Dial is compatible with any Bluetooth-enabled, Windows 10-enabled PC, laptop, and tablet running on Windows 10 Anniversary Update. 
** Surface Dial is on-screen compatible with Surface Studio and Surface Pro only. 

Windows 10 Creators Update fully available for all Windows 10 customers

For the past several months, I’ve shared insights on our roll out approach for Windows 10 Creators Update (version 1703). We’re now moving from a targeted offering to full availability for all compatible devices running Windows 10 globally via Windows Update. Similarly, our commercial customers should feel confident to deploy this release broadly across their organizations.

How to get the Windows 10 Creators Update

Predictable semi-annual release aligned with Office

In response to feedback for a more predictable feature update model, we are moving to a new twice-yearly release cadence called the Semi-Annual Channel that replaces the Current Branch (CB) and Current Branch for Business (CBB). As we announced in April, Windows has aligned with Office 365 ProPlus to simplify IT deployment cycles, targeting releases in March and September. Both feature releases will be serviced for 18 months from the date of release. The Creators Update marks the first of our Semi-Annual Channel releases.

Empowering organizations to decide when and how to deploy

The new Semi-Annual Channel update cadence and life cycle model provides commercial customers with greater predictability and simplicity to take advantage of the latest capabilities and integrated security, as quickly as is practical for their organization. This predictable release cycle enables enterprises to plan combined servicing of Windows and Office and create deployment plans tailored to their needs.

Starting with the Windows Insider Program for Business, IT Pro early adopters can evaluate pre-release builds early and provide feedback across the ecosystem – to us and their IHV/ISV partners – so we can, together as an ecosystem, build reliable, highly productive and secure products and experiences for our customers. When the Semi-Annual Channel feature update is released, organizations can begin targeted deployments to a select group of machines to validate their apps, devices, and infrastructure, prior to beginning a broad deployment at a time that is right for them. For details on Semi-Annual Channel servicing, see our article on TechNet.

You’re most secure on the latest version of Windows 10  

We are excited to make the Creators Update fully available to all our customers. We also encourage commercial organizations to begin broadly deploying Windows 10, version 1703, if you haven’t already done so. You can verify your system is up to date on the Windows Security page. We will continue to ensure all eligible devices can now move forward to the Creators Update, if you are having trouble updating your device, see this helpful article. Staying up to date on both the latest feature and quality updates assures you of being on the most secure version of Windows 10 ever (version 1703).

MS Paint is here to stay

We still love MS Paint written out in MS Paint

Today, we’ve seen an incredible outpouring of support and nostalgia around MS Paint. If there’s anything we learned, it’s that after 32 years, MS Paint has a lot of fans. It’s been amazing to see so much love for our trusty old app. Amidst today’s commentary around MS Paint we wanted to take this opportunity to set the record straight, clear up some confusion and share some good news:

MS Paint is here to stay, it will just have a new home soon, in the Windows Store where it will be available for free.

Paint 3D – the new app for creativity, also available for free with the Windows 10 Creators Update, will continue to get new feature updates. In addition to the new 3D capabilities, many of the MS Paint features people know and love like photo editing, line and curve tools, and 2D creation are in Paint 3D.

So, thanks for all the MS Paint love, keep the feedback coming via the Paint 3D app, and keep creating!

New Lights and PropertySet Interop – XAML and Visual Layer Interop, Part Two

In the last post, we explored using XamlCompositionBrushBase and LoadedImageSurface to create custom CompositionBrushes that can be used to paint XAML elements directly in your markup. In today’s post, we’ll continue our look into the new improvements made to the XAML and Visual Layer Interop APIs available in the Windows 10 Creators Update.

In this blog series, we’ll cover some of these improvements in the Creators Update and look at the following APIs:

  • In Part 1:
    • XamlCompositionBrushBase – easily paint a XAML UIElement with a CompositionBrush
    • LoadedImageSurface – load an image easily and use with Composition APIs
  • In Part 2, today’s post:
    • XamlLights – apply lights to your XAML UI with a single line of XAML
    • PointerPositionPropertySet – create 60 FPS animations using pointer position, off the UI thread!
    • Enabling the Translation property – animate a XAML UI Element using Composition animation

If you’d like to review the previously available ElementCompositionPreview APIs, for example working with “hand-in” and “hand-out” Visuals, you can quickly catch up here.

Lighting UI with XamlLights

A powerful new feature in the Creators Update is the ability to set and use a Lighting effect directly in XAML by leveraging the abstract XamlLight class.

Creating a XamlLight starts just like a XamlCompositionBrushBase does, with an OnConnected and OnDisconnected method (see Part One here), but this time you inherit from the XamlLight subclass to create your own unique lighting that can be used directly in XAML. Microsoft uses this with the Reveal effect that comes with the Creators Update.

To see this in action, let’s build a demo that creates the animated GIF you see at the top of this post. It combines everything you learned about XamlCompositionBrushBase and LoadedImageSurface in the last post, but this example has two XamlLights: a HoverLight and an AmbientLight.

Let’s begin with creating the AmbientLight first. To get started, we begin similarly to the XamlCompositionBrushBase with an OnConnected and OnDisconnected method. However, for a XamlLight we set the CompositionLight property of the XamlLight subclass.


public class AmbLight : XamlLight
{
    protected override void OnConnected(UIElement newElement)
    {
        Compositor compositor = Window.Current.Compositor;

        // Create AmbientLight and set its properties
        AmbientLight ambientLight = compositor.CreateAmbientLight();
        ambientLight.Color = Colors.White;

        // Associate CompositionLight with XamlLight
        CompositionLight = ambientLight;

        // Add UIElement to the Light's Targets
        AmbLight.AddTargetElement(GetId(), newElement);
    }

    protected override void OnDisconnected(UIElement oldElement)
    {
        // Dispose Light when it is removed from the tree
        AmbLight.RemoveTargetElement(GetId(), oldElement);
        CompositionLight.Dispose();
    }

    protected override string GetId() =&gt; typeof(AmbLight).FullName;
}

With ambient lighting done, let’s build the SpotLight XamlLight. One of the main things we want the SpotLight to do is follow the user’s pointer. To do this, we can now use GetPointerPositionPropertySet method of ElementCompositionPreview to get a CompositionPropertySet we can use with a Composition ExpressionAnimation (PointerPositionPropertySet is explained in more detail in the PropertySets section below).

Here is the finished XamlLight implementation that creates that animated spotlight. Read the code comments to see the main parts of the effects, particularly how the resting position and animated offset position are used to create the lighting.


public class HoverLight : XamlLight 
{
    private ExpressionAnimation _lightPositionExpression;
    private Vector3KeyFrameAnimation _offsetAnimation;

    protected override void OnConnected(UIElement targetElement)
    {
        Compositor compositor = Window.Current.Compositor;

        // Create SpotLight and set its properties
        SpotLight spotLight = compositor.CreateSpotLight();
        spotLight.InnerConeAngleInDegrees = 50f;
        spotLight.InnerConeColor = Colors.FloralWhite;
        spotLight.OuterConeAngleInDegrees = 0f;
        spotLight.ConstantAttenuation = 1f;
        spotLight.LinearAttenuation = 0.253f;
        spotLight.QuadraticAttenuation = 0.58f;

        // Associate CompositionLight with XamlLight
        this.CompositionLight = spotLight;

        // Define resting position Animation
        Vector3 restingPosition = new Vector3(200, 200, 400);
        CubicBezierEasingFunction cbEasing = compositor.CreateCubicBezierEasingFunction( new Vector2(0.3f, 0.7f), new Vector2(0.9f, 0.5f));
        _offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
        _offsetAnimation.InsertKeyFrame(1, restingPosition, cbEasing);
        _offsetAnimation.Duration = TimeSpan.FromSeconds(0.5f);

        spotLight.Offset = restingPosition;

        // Define expression animation that relates light's offset to pointer position 
        CompositionPropertySet hoverPosition = ElementCompositionPreview.GetPointerPositionPropertySet(targetElement);
        _lightPositionExpression = compositor.CreateExpressionAnimation(&quot;Vector3(hover.Position.X, hover.Position.Y, height)&quot;);
        _lightPositionExpression.SetReferenceParameter(&quot;hover&quot;, hoverPosition);
        _lightPositionExpression.SetScalarParameter(&quot;height&quot;, 15.0f);

        // Configure pointer entered/ exited events
        targetElement.PointerMoved += TargetElement_PointerMoved;
        targetElement.PointerExited += TargetElement_PointerExited;

        // Add UIElement to the Light's Targets
        HoverLight.AddTargetElement(GetId(), targetElement);
    }

    private void MoveToRestingPosition()
    {
        // Start animation on SpotLight's Offset 
        CompositionLight?.StartAnimation(&quot;Offset&quot;, _offsetAnimation);
    }

    private void TargetElement_PointerMoved(object sender, PointerRoutedEventArgs e)
    {
        if (CompositionLight == null) return;

        // touch input is still UI thread-bound as of the Creators Update
        if (e.Pointer.PointerDeviceType == Windows.Devices.Input.PointerDeviceType.Touch)
        {
            Vector2 offset = e.GetCurrentPoint((UIElement)sender).Position.ToVector2();
            (CompositionLight as SpotLight).Offset = new Vector3(offset.X, offset.Y, 15);
        }
        else
        {
            // Get the pointer's current position from the property and bind the SpotLight's X-Y Offset
            CompositionLight.StartAnimation(&quot;Offset&quot;, _lightPositionExpression);
        }
    }

    private void TargetElement_PointerExited(object sender, PointerRoutedEventArgs e)
    {
        // Move to resting state when pointer leaves targeted UIElement
        MoveToRestingPosition();
    }

    protected override void OnDisconnected(UIElement oldElement)
    {
        // Dispose Light and Composition resources when it is removed from the tree
        HoverLight.RemoveTargetElement(GetId(), oldElement);
        CompositionLight.Dispose();
        _lightPositionExpression.Dispose();
        _offsetAnimation.Dispose();
    }

    protected override string GetId() =&gt; typeof(HoverLight).FullName;
}

Now, with the HoverLight class done, we can add both the AmbLight and the HoverLight to previous ImageEffectBrush (find ImageEffectBrush in the last post):


&lt;Grid&gt;
            &lt;Grid.Background&gt;
                &lt;brushes:ImageEffectBrush ImageUriString=&quot;ms-appx:///Images/Background.png&quot; /&gt;
            &lt;/Grid.Background&gt;
 
            &lt;Grid.Lights&gt;
                &lt;lights:HoverLight/&gt;
                &lt;lights:AmbLight/&gt;
            &lt;/Grid.Lights&gt;
&lt;/Grid&gt;

Note: To add a XamlLight in markup, your Min SDK version must be set to Creators Update, otherwise you can set it in the code behind.

For more information, go here to read more about using XamlLight and here to see the Lighting documentation.

Using CompositionPropertySets

When you want to use the values of the ScrollViewer’s Offset or the Pointer’s X and Y position (e.g. mouse cursor) to do things like animate effects, you can use ElementCompositionPreview to retrieve their PropertySets. This allows you to create amazingly smooth, 60 FPS animations that are not tied to the UI thread. These methods let you get the values from user interaction for things like animations and lighting.

Using ScrollViewerManipulationPropertySet

This PropertySet is useful for animating things like Parallax, Translation and Opacity.


// Gets the manipulation &lt;ScrollViewer x:Name=&quot;MyScrollViewer&quot;/&gt;
CompositionPropertySet scrollViewerManipulationPropertySet = 
    ElementCompositionPreview.GetScrollViewerManipulationPropertySet(MyScrollViewer);

To see an example, go to the Smooth Interaction and Motion blog post in this series. There is a section devoted to using the ScrollViewerManipulationPropertySet to drive the animation.

Using PointerPositionPropertySet (new!)

New in the Creators Update, is the PointerPositionPropertySet. This PropertySet is useful for creating animations for lighting and tilt. Like ScrollViewerManipulationPropertySet, PointerPositionPropertySet enables fast, smooth and UI thread independent animations.

A great example of this is the animation mechanism behind Fluent Design’s RevealBrush, where you see lighting effects on the edges on the UIElements. This effect is created by a CompositionLight, which has an Offset property animated by an ExpressionAnimation using the values obtained from the PointerPositionPropertySet.


// Useful for creating an ExpressionAnimation
CompositionPropertySet pointerPositionPropertySet = ElementCompositionPreview.GetPointerPositionPropertySet(targetElement);
ExpressionAnimation expressionAnimation = compositor.CreateExpressionAnimation(&quot;Vector3(param.Position.X, param.Position.Y, height)&quot;);
expressionAnimation.SetReferenceParameter(&quot;param&quot;, pointerPositionPropertySet);

To get a better understanding of how you can use this to power animations in your app, let’s explore XamlLights and create a demo that uses the PointerPositionPropertySet to animate a SpotLight.

Enabling Translation Property – Animating a XAML Element’s Offset using Composition Animations

As discussed in our previous blog post, property sharing between the Framework Layer and the Visual Layer used to be tricky prior to the Creators Update. The following Visual properties are shared between UIElements and their backing Visuals:

  • Offset
  • Scale
  • Opacity
  • TransformMatrix
  • InsetClip
  • CompositeMode

Prior to the Creators update, Scale and Offset were especially tricky because, as mentioned before, a UIElement isn’t aware of changes to the property values on the hand-out Visual, even though the hand-out Visual is aware of changes to the UIElement. Consequently, if you change the value of the hand-out Visual’s Offset or Size property and the UIElement’s position changes due to a page resize, the UIElement’s previous position values will stomp all over your hand-out Visual’s values.

Now with the Creators Update, this has become much easier to deal with as you can prevent Scale and Offset stomping by enabling the new Translation property on your element, by way of the ElementCompositionPreview object.


ElementCompositionPreview.SetIsTranslationEnabled(Rectangle1, true);

//Now initialize the value of Translation in the PropertySet to zero for first use to avoid timing issues. This ensures that the property is ready for use immediately.

var rect1VisualPropertySet = ElementCompositionPreview.GetElementVisual(Rectangle1).Properties;
rect1VisualPropertySet.InsertVector3(&quot;Translation&quot;, Vector3.Zero);

Then, animate the visual’s Translation property where previously you would have animated its Offset property.


// Old way, subject to property stomping:
visual.StartAnimation(&quot;Offset.Y&quot;, animation);
// New way, available in the Creators Update
visual.StartAnimation(&quot;Translation.Y&quot;, animation);

By animating a different property from the one affected during layout passes, you avoid any unwanted offset stomping coming from the XAML layer.

Wrapping up

In the past couple posts, we explored some of the new features of XAML and Composition Interop and how using Composition features in your XAML markup is easier than ever. From painting your UIElements with CompositionBrushes and applying lighting, to smooth off-UIThread animations, the power of the Composition API is more accessible than ever.

In the next post, we’ll dive deeper into how you can chain Composition effects to create amazing materials and help drive the evolution of Fluent Design.

Resources

Working with Brushes and Content – XAML and Visual Layer Interop, Part One

The Composition APIs empower Universal Windows Platform (UWP) developers to do beautiful and powerful things when they access the Visual Layer. In the Windows 10 Creators Update, we made working with the Visual Layer much easier with new, powerful APIs.

In this blog series, we’ll cover some of these improvements in the Creators Update and take a look at the following APIs:

  • In Part 1, today’s post:
    • XamlCompositionBrushBase – easily paint a XAML UIElement with a CompositionBrush
    • LoadedImageSurface – load an image easily and use with Composition APIs
  • In Part 2, we’ll look at:
    • XamlLights – apply lights to your XAML UI with a single line of XAML
    • PointerPositionPropertySet – create 60 FPS animations using pointer position, off the UI thread!
    • Enabling the Translation property – animate a XAML UI Element using Composition animation

If you’d like to review the previously available ElementCompositionPreview APIs, for example working with “hand-in” and “hand-out” Visuals, you can quickly catch up here.

Using XamlCompositionBrushBase

One of the benefits of the new Composition and XAML interop APIs is the ability to use a CompositionBrush to directly paint a XAML UIElement rather than being limited to XAML brushes only. For example, you can create a CompositionEffectBrush that applies a tinted blur to the content beneath and use the brush to paint a XAML rectangle that can be included in the XAML markup

This is accomplished by using the new abstract class XamlCompositionBrushBase available in the Creators Update. To use it, you subclass XamlCompositionBrushBase to create your own XAML Brush that can be used in your markup. As seen the example code below, the XamlCompositionBrushBase exposes a CompositionBrush property that you set with your effect (or any CompositionBrush) and it will be applied to the XAML element.

This effectively replaces the need to manually create SpriteVisuals with SetElementChild for most effect scenarios. In addition to needing less code to create and add an effect to the UI, using a Brush means you get the following added benefits for free:

  • Theming and Styling
  • Binding
  • Resource and Lifetime management
  • Layout aware
  • PointerEvents
  • HitTesting and other XAML-based advantages

Microsoft, as part of the Fluent Design System, has included a few Brushes in the Creators Update that leverage the features of XamlCompositionBrushBase:

Building a Custom Composition Brush

Let’s create a XamlCompositionBrush of our own to see how simple this can be.  Here’s what we’ll create:

To start, let’s create a very simple Brush that applies an InvertEffect to content under it. First, we’ll need to make a public sealed class that inherits from XamlCompositionBrushBase and override two methods:

  • OnConnected
  • OnDisconnected

Let’s dive into the code. First, create your Brush class, which inherits from XamlCompositionBrushBase:


public class InvertBrush : XamlCompositionBrushBase
{
    protected override void OnConnected()
    {
        if (CompositionBrush == null)
        {
            // 1 - Get the BackdropBrush, this gets what is behind the UI element
            var backdrop = Window.Current.Compositor.CreateBackdropBrush();

            // CompositionCapabilities: Are effects supported? If not, return.
            if (!CompositionCapabilities.GetForCurrentView().AreEffectsSupported())
            { 
               return;
            }
                
            // 2 - Create your Effect
            // New-up a Win2D InvertEffect and use the BackdropBrush as its Source
            // Note – To use InvertEffect, you'll need to add the Win2D NuGet package to your project (search NuGet for &amp;quot;Win2D.uwp&amp;quot;)
            var invertEffect = new InvertEffect
            {
                Source = new CompositionEffectSourceParameter(&amp;quot;backdrop&amp;quot;)
            };

            // 3 - Set up the EffectFactory
            var effectFactory = Window.Current.Compositor.CreateEffectFactory(invertEffect);

            // 4 - Finally, instantiate the CompositionEffectBrush
            var effectBrush = effectFactory.CreateBrush();

            // and set the backdrop as the original source 
            effectBrush.SetSourceParameter(&amp;quot;backdrop&amp;quot;, backdrop);

            // 5 - Finally, assign your CompositionEffectBrush to the XCBB's CompositionBrush property
            CompositionBrush = effectBrush;
         }
    }

    protected override void OnDisconnected()
    {
        // Clean up
        CompositionBrush?.Dispose();
        CompositionBrush = null;
    }
}

There are a few things to call out in the code above.

  • In the OnConnected method, we get a CompositionBackdropBrush. This allows you to easily get the pixels behind the UIElement.
  • We use fallback protection. If the user’s device doesn’t have support for the effect(s), then just return.
  • Next, we create the InvertEffect and use the backdropBrush for the Effect’s Source.
  • Then, we pass the finished InvertEffect to the CompositionEffectFactory.
  • Finally, we get an EffectBrush from the factory and set the XamlCompositionBrushBase.CompositionBrush property with our newly created effectBrush.

Now you can use it in your XAML. For example, let’s apply it to a Grid on top of another Grid with a background image:


&amp;lt;Grid&amp;gt;
    &amp;lt;Grid.Background&amp;gt;
        &amp;lt;ImageBrush ImageSource=&amp;quot;ms-appx:///Images/Background.png&amp;quot;/&amp;gt;
    &amp;lt;/Grid.Background&amp;gt;
    &amp;lt;Grid Width=&amp;quot;300&amp;quot; Height=&amp;quot;300&amp;quot; 
               HorizontalAlignment=&amp;quot;Center&amp;quot;
               VerticalAlignment=&amp;quot;Center&amp;quot;&amp;gt;
        &amp;lt;Grid.Background&amp;gt;
            &amp;lt;brushes:InvertBrush /&amp;gt;
        &amp;lt;/Grid.Background&amp;gt;
    &amp;lt;/Grid&amp;gt;
&amp;lt;/Grid&amp;gt;

Now that you know the basics of creating a brush, let’s build an animated effect brush next.

Creating a Brush with Animating Effects

Now that you see how simple it is to create a CompositionBrush, let’s create a brush that applies a TemeratureAndTint effect to an image and animate the Temperature value:

We start the same way we did with the simple InvertBrush, but this time we’ll add a DependencyProperty,  ImageUriString, so that we can load an image using LoadedImageSurface in the OnConnected method.


public sealed class ImageEffectBrush : XamlCompositionBrushBase
    {
        private LoadedImageSurface _surface;
        private CompositionSurfaceBrush _surfaceBrush;
 
        public static readonly DependencyProperty ImageUriStringProperty = DependencyProperty.Register(
            &amp;quot;ImageUri&amp;quot;,
            typeof(string),
            typeof(ImageEffectBrush),
            new PropertyMetadata(string.Empty, OnImageUriStringChanged)
        );
 
        public string ImageUriString
        {
            get =&amp;gt; (String)GetValue(ImageUriStringProperty);
            set =&amp;gt; SetValue(ImageUriStringProperty, value);
        }
 
        private static void OnImageUriStringChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var brush = (ImageEffectBrush)d;
            // Unbox and update surface if CompositionBrush exists     
            if (brush._surfaceBrush != null)
            {
                var newSurface = LoadedImageSurface.StartLoadFromUri(new Uri((String)e.NewValue));
                brush._surface = newSurface;
                brush._surfaceBrush.Surface = newSurface;
            }
        }
 
        protected override void OnConnected()
        {
            // return if Uri String is null or empty
            if (string.IsNullOrEmpty(ImageUriString))
                return;
 
            // Get a reference to the Compositor
            Compositor compositor = Window.Current.Compositor;
 
            // Use LoadedImageSurface API to get ICompositionSurface from image uri provided
            _surface = LoadedImageSurface.StartLoadFromUri(new Uri(ImageUriString));
 
            // Load Surface onto SurfaceBrush
            _surfaceBrush = compositor.CreateSurfaceBrush(_surface);
            _surfaceBrush.Stretch = CompositionStretch.UniformToFill;
 
            // CompositionCapabilities: Are Tint+Temperature and Saturation supported?
            bool usingFallback = !CompositionCapabilities.GetForCurrentView().AreEffectsSupported();
            if (usingFallback)
            {
                // If Effects are not supported, Fallback to image without effects
                CompositionBrush = _surfaceBrush;
                return;
            }
 
            // Define Effect graph (add the Win2D.uwp NuGet package to get this effect)
            IGraphicsEffect graphicsEffect = new SaturationEffect
            {
                Name = &amp;quot;Saturation&amp;quot;,
                Saturation = 0.3f,
                Source = new TemperatureAndTintEffect
                {
                    Name = &amp;quot;TempAndTint&amp;quot;,
                    Temperature = 0,
                    Source = new CompositionEffectSourceParameter(&amp;quot;Surface&amp;quot;),
                }
            };
 
            // Create EffectFactory and EffectBrush 
            CompositionEffectFactory effectFactory = compositor.CreateEffectFactory(graphicsEffect, new[] { &amp;quot;TempAndTint.Temperature&amp;quot; });
            CompositionEffectBrush effectBrush = effectFactory.CreateBrush();
            effectBrush.SetSourceParameter(&amp;quot;Surface&amp;quot;, _surfaceBrush);
 
            // Set EffectBrush to paint Xaml UIElement
            CompositionBrush = effectBrush;
 
            // Trivial looping animation to demonstrate animated effect
            ScalarKeyFrameAnimation tempAnim = compositor.CreateScalarKeyFrameAnimation();
            tempAnim.InsertKeyFrame(0, 0);
            tempAnim.InsertKeyFrame(0.5f, 1f);
            tempAnim.InsertKeyFrame(1, 0);
            tempAnim.Duration = TimeSpan.FromSeconds(5);
            tempAnim.IterationBehavior = AnimationIterationBehavior.Count;
      tempAnim.IterationCount = 10;
             effectBrush.Properties.StartAnimation(&amp;quot;TempAndTint.Temperature&amp;quot;, tempAnim);
        }
 
        protected override void OnDisconnected()
        {
            // Dispose Surface and CompositionBrushes if XamlCompBrushBase is removed from tree
            _surface?.Dispose();
            _surface = null;
 
            CompositionBrush?.Dispose();
            CompositionBrush = null;
        }
    }

There are some new things here to call out that are different from the InvertBrush:

  • We use the new LoadedImageSurface API to easily load an image in the OnConnected method, but also when the ImageUriString value changes. Prior to Creators Update, this required a hand-in Visual (a SpriteVisual, painted with an EffectBrush, which was handed back into the XAML Visual Tree). See the LoadedImageSurface section later in this article for more details.
  • Notice that we gave the effects a Name value. In particular, TemperatureAndTintEffect, uses the name “TempAndTint.” This is required to animate properties as it is used for the reference to the effect in the AnimatableProperties array that is passed to the effect factory. Otherwise, you’ll encounter a “Malformed animated property name” error.
  • After we assign the CompositionBrush property, we created a simple looping animation to oscillate the value of the TempAndTint from 0 to 1 and back every 5 seconds.

Let’s take a look at an instance of this Brush in markup:


&amp;lt;Grid&amp;gt;
            &amp;lt;Grid.Background&amp;gt;
                &amp;lt;brushes:ImageEffectBrush ImageUriString=&amp;quot;ms-appx:///Images/Background.png&amp;quot;/&amp;gt;
            &amp;lt;/Grid.Background&amp;gt;
&amp;lt;/Grid&amp;gt;

For more information on using XamlCompositionBrushBase, see here. Now, let’s take a closer look at how easy it is now to bring in images to the Visual layer using LoadedImageSurface

Loading images with LoadedImageSurface

With the new LoadedImageSurface class, it’s never been easier to load an image and work with it in the visual layer. The class has the same codec support that Windows 10 has via the Windows Imaging Component (see full list here), thus it supports the following image file types:

  • Joint Photographic Experts Group (JPEG)
  • Portable Network Graphics (PNG)
  • Bitmap (BMP)
  • Graphics Interchange Format (GIF)
  • Tagged Image File Format (TIFF)
  • JPEG XR
  • Icons (ICO)

NOTE: When using an animated GIF, only the first frame will be used for the Visual, as animation is not supported in this scenario.

To load in an image, you can use one of the four factory methods:

As you can see there are two ways to load an image: with a Uri or a Stream. Additionally, you have an option to use an overload to set the size of the image (if you don’t pass in a Size, it will decode to the natural size).


CompositionSurfaceBrush imageBrush = compositor.CreateSurfaceBrush();
LoadedImageSurface loadedSurface = LoadedImageSurface.StartLoadFromUri(new Uri(&amp;quot;ms-appx:///Images/Photo.jpg&amp;quot;), new Size(200.0, 200.0));
imageBrush.Surface = loadedSurface;

This is very helpful when you need to load an image that will be used for your CompositionBrush (e.g. CompositionEffectBrush) or SceneLightingEffect (e.g. NormalMap for textures) as you no longer need to manually create a hand-in Visual (a SpriteVisual painted with an EffectBrush). In an upcoming post in this series, we will explore this further using NormalMap images with to create advanced lighting to create unique and compelling materials.

Using LoadedImageSurface with a Composition Island

LoadedImageSurface is also useful when loading an image onto a SpriteVisual inserted in XAML UI using ElementCompositionPreview. For this scenario, you can use the Loaded event to adjust the visual’s properties after the image has finished loading.

Here is an example of using LoadedImageSurface for a CompositionSurfaceBrush, then updating the SpriteVisual’s size with the image’s DecodedSize when the image is loaded:


private SpriteVisual spriteVisual;
private void LoadImage(Uri imageUri)
{
    CompositionSurfaceBrush surfaceBrush = Window.Current.Compositor.CreateSurfaceBrush();

    // You can load an image directly and set a SurfaceBrush's Surface property with it
    var loadedImageSurface = LoadedImageSurface.StartLoadFromUri(imageUri);
    loadedImageSurface.LoadCompleted += Load_Completed;
    surfaceBrush.Surface = loadedImageSurface;

    // We'll use a SpriteVisual for the hand-in visual
    spriteVisual = Window.Current.Compositor.CreateSpriteVisual();
    spriteVisual.Brush = surfaceBrush;

    ElementCompositionPreview.SetElementChildVisual(MyCanvas, spriteVisual);
}

private void Load_Completed(LoadedImageSurface sender, LoadedImageSourceLoadCompletedEventArgs args)
{
    if (args.Status == LoadedImageSourceLoadStatus.Success)
    {
        Size decodedSize = sender.DecodedSize;
        spriteVisual.Size = new Vector2((float)decodedSize.Width, (float)decodedSize.Height);
    }
}

There are some things you should be aware before getting started with LoadedImageSurface. This class makes working with images a lot easier, however you should understand the lifecycle and when images get decoded/sized. We recommend that you take a couple minutes and read the documentation before getting started.

Wrapping up

Using Composition features in your XAML markup is easier than ever. From painting your UIElements with CompositionBrushes and applying lighting, to smooth off-UIThread animations, the power of the Composition API is more accessible than ever.

In the next post, we’ll explore more new APIs like the new Translation property, using XamlLights in your XAML markup and how to create a custom light using the new PointerPositionPropertySet.

Resources

Windows 10 SDK Preview Build 16232 Released

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 16232 or greater). The Preview SDK Build 16232 contains bug fixes and under development changes to the API surface area.

The Preview SDK can be downloaded from developer section on Windows Insider.

For feedback and updates to the known issues, please see the developer forum. For new feature requests, head over to our Windows Platform UserVoice.

Things to note:

  • This build works in conjunction with previously released SDKs and Visual Studio 2017. You can install this SDK and still also continue to submit your apps that target Windows 10 Creators build or earlier to the store.
  • The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2017 here.

Known Issues

  • Designer fails to render: When viewing the XAML in the Designer Window in Visual Studio, the controls fail to render. This can be resolved by using Visual Studio 2017.3 Preview.
  • Compilation fails on non-Windows 10 platforms
    When building apps on previous platforms, you may get a build error:

C:program files (x86)Windows Kits10bin10.0.16232.0x86genxbf.dll:C:program files (x860Windows
Kits10bin10.0.16232.0x86genxbf.dll(0,0): Error WMC0621: Cannot resolve ‘GenXbf.dll’ under path ‘C:program files (x860Windows
Kits10bin10.0.16232.0x86genxbf.dll’. Please install the latest version of the Windows 10 Software Development Kit.
Process ‘msbuild.exe’ exited with code ‘1’.

This will occur if the minimum target platform version is set to 10.0.16225.0. To work around this, right click on your project file and choose properties or open your project file in your favorite editor, and change the version to a previous released SDK. For example:


&amp;lt;WindowsTargetPlatformMinVersion&amp;gt;10.0.10586.0&amp;lt;/WindowsTargetPlatformMinVersion&amp;gt;

  • WRL projects fail to compile with MIDLRT error: When building my WRL project that contains a WinRT Component, the project no longer compiles. I get the following errors:

midlrt : command line error MIDL1012: [msg]argument illegal for switch / [context]ns_prefix
midlrt : command line error MIDL1000: [msg]missing source-file name

To work around this temporarily, you will need to use the previous version of the MidlRT.exe tool. You can do this by changing your Target Platform Version to a currently installed previous SDK.


&amp;lt;WindowsTargetPlatformVersion&amp;gt;10.0.15063.0&amp;lt;/WindowsTargetPlatformVersion&amp;gt;

Breaking Changes

  • ecmangen.exe removal from the SDK: Ecmangen.exe will no longer ship with the Windows SDK. Developers who rely on ecmangen for event manifest creation are advised to install the Windows Creators Edition of the SDK to obtain the file. Developers may also use notepad or other XML editor of choice for manifest creation. A schema file is available on MSDN to aid in manifest creation, for tools that support it.

API Differences from Windows 10 Creators Update

When targeting new APIs, consider writing your app to be adaptive in order to run correctly on the widest number of Windows 10 devices. Please see Dynamically detecting features with API contracts (10 by 10) for more information.

API Additions


namespace Windows.ApplicationModel.Calls {
  public sealed class VoipCallCoordinator {
    VoipPhoneCall SetupNewAcceptedCall(string context, string contactName, string contactNumber, string serviceName, VoipPhoneCallMedia media);
  }
  public sealed class VoipPhoneCall {
    void TryShowAppUI();
  }
}
 
namespace Windows.ApplicationModel {
  public enum StartupTaskState {
    DisabledByPolicy = 3,
  }
}
 
namespace Windows.Devices.SmartCards {
  public sealed class SmartCardCryptogramGenerator {
    public static bool IsSupported();
  }
  public enum SmartCardCryptogramGeneratorOperationStatus {
    NotSupported = 13,
  }
  public sealed class SmartCardEmulator {
    public static bool IsSupported();
  }
}
namespace Windows.ApplicationModel {
  public static class DesignMode {
    public static bool DesignMode2Enabled { get; }
  }
  public sealed class PackageCatalog {
    IAsyncOperation&amp;lt;PackageCatalogRemoveOptionalPackagesResult&amp;gt; RemoveOptionalPackagesAsync(IIterable&amp;lt;string&amp;gt; optionalPackageFamilyNames);
  }
  public sealed class PackageCatalogRemoveOptionalPackagesResult
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    CommandLineLaunch = 1021,
    GameUIProvider = 1019,
    PrintWorkflowForegroundTask = 1018,
    StartupTask = 1020,
  }
  public sealed class CommandLineActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, ICommandLineActivatedEventArgs
  public sealed class CommandLineActivationOperation
  public interface ICommandLineActivatedEventArgs : IActivatedEventArgs
  public interface IStartupTaskActivatedEventArgs : IActivatedEventArgs
  public sealed class StartupTaskActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IStartupTaskActivatedEventArgs
}
namespace Windows.ApplicationModel.Appointments {
  public sealed class AppointmentStore {
    AppointmentStoreChangeTracker GetChangeTracker(string identity);
  }
  public sealed class AppointmentStoreChangeTracker {
    bool IsTracking { get; }
  }
}
namespace Windows.ApplicationModel.AppService {
  public sealed class AppServiceTriggerDetails {
    IAsyncOperation&amp;lt;bool&amp;gt; CheckCallerForCapabilityAsync(string capabilityName);
  }
}
namespace Windows.ApplicationModel.Background {
  public sealed class GeovisitTrigger : IBackgroundTrigger
  public sealed class PaymentAppCanMakePaymentTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Contacts {
  public sealed class ContactChangeTracker {
    bool IsTracking { get; }
  }
  public sealed class ContactList {
    ContactListLimitedWriteOperations LimitedWriteOperations { get; }
    ContactChangeTracker GetChangeTracker(string identity);
  }
  public sealed class ContactListLimitedWriteOperations
  public enum ContactListOtherAppWriteAccess {
    Limited = 2,
  }
  public sealed class ContactStore {
    ContactChangeTracker GetChangeTracker(string identity);
  }
}
namespace Windows.ApplicationModel.Contacts.DataProvider {
  public sealed class ContactDataProviderConnection {
    event TypedEventHandler&amp;lt;ContactDataProviderConnection, ContactListCreateOrUpdateContactRequestEventArgs&amp;gt; CreateOrUpdateContactRequested;
    event TypedEventHandler&amp;lt;ContactDataProviderConnection, ContactListDeleteContactRequestEventArgs&amp;gt; DeleteContactRequested;
  }
  public sealed class ContactListCreateOrUpdateContactRequest
  public sealed class ContactListCreateOrUpdateContactRequestEventArgs
  public sealed class ContactListDeleteContactRequest
  public sealed class ContactListDeleteContactRequestEventArgs
}
namespace Windows.ApplicationModel.Core {
  public sealed class AppListEntry {
    string AppUserModelId { get; }
  }
  public enum AppRestartFailureReason
  public static class CoreApplication {
    public static IAsyncOperation&amp;lt;AppRestartFailureReason&amp;gt; RequestRestartAsync(string launchArguments);
    public static IAsyncOperation&amp;lt;AppRestartFailureReason&amp;gt; RequestRestartForUserAsync(User user, string launchArguments);
  }
  public sealed class CoreApplicationView {
    DispatcherQueue DispatcherQueue { get; }
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataTransferManager {
    public static void ShowShareUI(ShareUIOptions options);
  }
  public sealed class ShareUIOptions
  public enum ShareUITheme
}
namespace Windows.ApplicationModel.DataTransfer.ShareTarget {
  public sealed class ShareOperation {
    IVectorView&amp;lt;Contact&amp;gt; Contacts { get; }
  }
}
namespace Windows.ApplicationModel.Email {
  public sealed class EmailMailbox {
    EmailMailboxChangeTracker GetChangeTracker(string identity);
  }
}
namespace Windows.ApplicationModel.Payments {
  public sealed class PaymentCanMakePaymentResult
  public enum PaymentCanMakePaymentResultStatus
  public sealed class PaymentMediator {
    IAsyncOperation&amp;lt;PaymentCanMakePaymentResult&amp;gt; CanMakePaymentAsync(PaymentRequest paymentRequest);
  }
  public sealed class PaymentRequest {
    public PaymentRequest(PaymentDetails details, IIterable&amp;lt;PaymentMethodData&amp;gt; methodData, PaymentMerchantInfo merchantInfo, PaymentOptions options, string id);
    string Id { get; }
  }
}
namespace Windows.ApplicationModel.Payments.Provider {
  public sealed class PaymentAppCanMakePaymentTriggerDetails
}
namespace Windows.ApplicationModel.UserActivities {
  public interface IUserActivityContentInfo
  public sealed class UserActivity
  public sealed class UserActivityAttribution
  public sealed class UserActivityChannel
  public sealed class UserActivityContentInfo : IUserActivityContentInfo
  public sealed class UserActivitySession : IClosable
  public enum UserActivityState
  public sealed class UserActivityVisualElements
}
namespace Windows.ApplicationModel.UserActivities.Core {
  public static class CoreUserActivityManager
}
namespace Windows.Devices.Bluetooth {
  public sealed class BluetoothDevice : IClosable {
    BluetoothDeviceId BluetoothDeviceId { get; }
  }
  public sealed class BluetoothDeviceId {
    public static BluetoothDeviceId FromId(string deviceId);
  }
  public sealed class BluetoothLEDevice : IClosable {
    BluetoothDeviceId BluetoothDeviceId { get; }
  }
}
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
  public sealed class GattClientNotificationResult {
    ushort BytesSent { get; }
  }
}
namespace Windows.Devices.Geolocation {
  public sealed class Geovisit
  public sealed class GeovisitMonitor
  public sealed class GeovisitStateChangedEventArgs
  public sealed class GeovisitTriggerDetails
  public enum VisitMonitoringScope
  public enum VisitStateChange
}
namespace Windows.Devices.PointOfService {
  public sealed class ClaimedLineDisplay : IClosable {
    LineDisplayCustomGlyphs CustomGlyphs { get; }
    Size MaxBitmapSizeInPixels { get; }
    IVectorView&amp;lt;int&amp;gt; SupportedCharacterSets { get; }
    IVectorView&amp;lt;Size&amp;gt; SupportedScreenSizesInCharacters { get; }
    event TypedEventHandler&amp;lt;ClaimedLineDisplay, LineDisplayStatusUpdatedEventArgs&amp;gt; StatusUpdated;
    IAsyncOperation&amp;lt;string&amp;gt; CheckHealthAsync(UnifiedPosHealthCheckLevel level);
    IAsyncOperation&amp;lt;LineDisplayPowerStatus&amp;gt; CheckPowerStatusAsync();
    LineDisplayAttributes GetAttributes();
    IAsyncOperation&amp;lt;string&amp;gt; GetStatisticsAsync(IIterable&amp;lt;string&amp;gt; statisticsCategories);
    IAsyncOperation&amp;lt;bool&amp;gt; TryClearDescriptorsAsync();
    IAsyncOperation&amp;lt;LineDisplayWindow&amp;gt; TryCreateWindowAsync(Rect viewport, Size windowSize);
    IAsyncOperation&amp;lt;bool&amp;gt; TrySetDescriptorAsync(uint descriptor, LineDisplayDescriptorState descriptorState);
    IAsyncOperation&amp;lt;LineDisplayStoredBitmap&amp;gt; TryStoreStorageFileBitmapAsync(StorageFile bitmap);
    IAsyncOperation&amp;lt;LineDisplayStoredBitmap&amp;gt; TryStoreStorageFileBitmapAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment);
    IAsyncOperation&amp;lt;LineDisplayStoredBitmap&amp;gt; TryStoreStorageFileBitmapAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment, int widthInPixels);
    IAsyncOperation&amp;lt;bool&amp;gt; TryUpdateAttributesAsync(LineDisplayAttributes attributes);
  }
  public sealed class LineDisplay : IClosable {
    public static LineDisplayStatisticsCategorySelector StatisticsCategorySelector { get; }
    IAsyncOperation&amp;lt;LineDisplayPowerStatus&amp;gt; CheckPowerStatusAsync();
  }
  public sealed class LineDisplayAttributes
  public sealed class LineDisplayCursor
  public sealed class LineDisplayCursorAttributes
  public enum LineDisplayCursorType
  public sealed class LineDisplayCustomGlyphs
  public enum LineDisplayDescriptorState
  public enum LineDisplayHorizontalAlignment
  public sealed class LineDisplayMarquee
  public enum LineDisplayMarqueeFormat
  public enum LineDisplayPowerStatus
  public sealed class LineDisplayStatisticsCategorySelector
  public sealed class LineDisplayStatusUpdatedEventArgs
  public sealed class LineDisplayStoredBitmap
  public enum LineDisplayVerticalAlignment
  public sealed class LineDisplayWindow : IClosable {
    LineDisplayCursor Cursor { get; }
    LineDisplayMarquee Marquee { get; }
    IAsyncOperation&amp;lt;uint&amp;gt; ReadCharacterAtCursorAsync();
    IAsyncOperation&amp;lt;bool&amp;gt; TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap);
    IAsyncOperation&amp;lt;bool&amp;gt; TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment);
    IAsyncOperation&amp;lt;bool&amp;gt; TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment, int widthInPixels);
    IAsyncOperation&amp;lt;bool&amp;gt; TryDisplayStorageFileBitmapAtPointAsync(StorageFile bitmap, Point offsetInPixels);
    IAsyncOperation&amp;lt;bool&amp;gt; TryDisplayStorageFileBitmapAtPointAsync(StorageFile bitmap, Point offsetInPixels, int widthInPixels);
    IAsyncOperation&amp;lt;bool&amp;gt; TryDisplayStoredBitmapAtCursorAsync(LineDisplayStoredBitmap bitmap);
  }
}
namespace Windows.Devices.Sensors {
  public sealed class Accelerometer {
    public static IAsyncOperation&amp;lt;Accelerometer&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector(AccelerometerReadingType readingType);
  }
  public sealed class AccelerometerReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class Altimeter {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
  }
  public sealed class AltimeterReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class Barometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;Barometer&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class BarometerReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class Compass {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;Compass&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class CompassReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class Gyrometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;Gyrometer&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class GyrometerReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class Inclinometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;Inclinometer&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector(SensorReadingType readingType);
  }
  public sealed class InclinometerReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class LightSensor {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;LightSensor&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class LightSensorReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class Magnetometer {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;Magnetometer&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
  }
  public sealed class MagnetometerReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
  public sealed class OrientationSensor {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
    public static IAsyncOperation&amp;lt;OrientationSensor&amp;gt; FromIdAsync(string deviceId);
    public static string GetDeviceSelector(SensorReadingType readingType);
    public static string GetDeviceSelector(SensorReadingType readingType, SensorOptimizationGoal optimizationGoal);
  }
  public sealed class OrientationSensorReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
    IMapView&amp;lt;string, object&amp;gt; Properties { get; }
  }
}
namespace Windows.Devices.Sensors.Custom {
  public sealed class CustomSensor {
    uint MaxBatchSize { get; }
    uint ReportLatency { get; set; }
  }
  public sealed class CustomSensorReading {
    IReference&amp;lt;TimeSpan&amp;gt; PerformanceCount { get; }
  }
}
namespace Windows.Devices.WiFi {
  public sealed class WiFiAdapter {
    IAsyncOperation&amp;lt;WiFiConnectionResult&amp;gt; ConnectAsync(WiFiAvailableNetwork availableNetwork, WiFiReconnectionKind reconnectionKind, PasswordCredential passwordCredential, string ssid, WiFiConnectionMethod connectionMethod);
    IAsyncOperation&amp;lt;WiFiWpsConfigurationResult&amp;gt; GetWpsConfigurationAsync(WiFiAvailableNetwork availableNetwork);
  }
  public enum WiFiConnectionMethod
  public sealed class WiFiWpsConfigurationResult
  public enum WiFiWpsConfigurationStatus
  public enum WiFiWpsKind
}
namespace Windows.Gaming.Input {
  public sealed class RawGameController : IGameController, IGameControllerBatteryInfo {
    string DisplayName { get; }
    string NonRoamableId { get; }
    IVectorView&amp;lt;SimpleHapticsController&amp;gt; SimpleHapticsControllers { get; }
  }
}
namespace Windows.Gaming.UI {
  public sealed class GameMonitor
  public enum GameMonitoringPermission
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    bool IsPrimaryLayerEnabled { get; set; }
    uint MaxQuadLayerCount { get; }
    IVector&amp;lt;HolographicQuadLayer&amp;gt; QuadLayers { get; }
  }
  public sealed class HolographicCameraRenderingParameters {
    bool IsContentProtectionEnabled { get; set; }
  }
  public sealed class HolographicDisplay {
    double RefreshRate { get; }
  }
  public sealed class HolographicFrame {
    HolographicQuadLayerUpdateParameters GetQuadLayerUpdateParameters(HolographicQuadLayer layer);
  }
  public sealed class HolographicQuadLayer : IClosable
  public sealed class HolographicQuadLayerUpdateParameters
  public sealed class HolographicSpace {
    public static bool IsConfigured { get; }
  }
}
namespace Windows.Graphics.Printing.PrintTicket {
  public sealed class PrintTicketCapabilities
  public sealed class PrintTicketFeature
  public enum PrintTicketFeatureSelectionType
  public sealed class PrintTicketOption
  public enum PrintTicketParameterDataType
  public sealed class PrintTicketParameterDefinition
  public sealed class PrintTicketParameterInitializer
  public sealed class PrintTicketValue
  public enum PrintTicketValueType
  public sealed class WorkflowPrintTicket
  public sealed class WorkflowPrintTicketValidationResult
}
namespace Windows.Graphics.Printing.Workflow {
  public sealed class PrintWorkflowBackgroundSession
  public sealed class PrintWorkflowBackgroundSetupRequestedEventArgs
  public sealed class PrintWorkflowConfiguration
  public sealed class PrintWorkflowForegroundSession
  public sealed class PrintWorkflowForegroundSetupRequestedEventArgs
  public sealed class PrintWorkflowObjectModelSourceFileContent
  public sealed class PrintWorkflowObjectModelTargetPackage
  public enum PrintWorkflowSessionStatus
  public sealed class PrintWorkflowSourceContent
  public sealed class PrintWorkflowSpoolStreamContent
  public sealed class PrintWorkflowStreamTarget
  public sealed class PrintWorkflowSubmittedEventArgs
  public sealed class PrintWorkflowSubmittedOperation
  public enum PrintWorkflowSubmittedStatus
  public sealed class PrintWorkflowTarget
  public sealed class PrintWorkflowTriggerDetails
  public sealed class PrintWorkflowUIActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser
  public sealed class PrintWorkflowXpsDataAvailableEventArgs
}
namespace Windows.Management.Deployment {
  public enum AddPackageByAppInstallerOptions : uint
  public sealed class PackageManager {
    IAsyncOperationWithProgress&amp;lt;DeploymentResult, DeploymentProgress&amp;gt; AddPackageAsync(Uri packageUri, IIterable&amp;lt;Uri&amp;gt; dependencyPackageUris, DeploymentOptions options, PackageVolume targetVolume, IIterable&amp;lt;string&amp;gt; optionalPackageFamilyNames, IIterable&amp;lt;Uri&amp;gt; packageUrisToInstall, IIterable&amp;lt;Uri&amp;gt; relatedPackageUris);
    IAsyncOperationWithProgress&amp;lt;DeploymentResult, DeploymentProgress&amp;gt; AddPackageByAppInstallerFileAsync(Uri appInstallerFileUri, AddPackageByAppInstallerOptions options, PackageVolume targetVolume);
    IAsyncOperationWithProgress&amp;lt;DeploymentResult, DeploymentProgress&amp;gt; ProvisionPackageForAllUsersAsync(string packageFamilyName);
    IAsyncOperationWithProgress&amp;lt;DeploymentResult, DeploymentProgress&amp;gt; RequestAddPackageAsync(Uri packageUri, IIterable&amp;lt;Uri&amp;gt; dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable&amp;lt;string&amp;gt; optionalPackageFamilyNames, IIterable&amp;lt;Uri&amp;gt; relatedPackageUris);
    IAsyncOperationWithProgress&amp;lt;DeploymentResult, DeploymentProgress&amp;gt; RequestAddPackageByAppInstallerFileAsync(Uri appInstallerFileUri, AddPackageByAppInstallerOptions options, PackageVolume targetVolume);
    IAsyncOperationWithProgress&amp;lt;DeploymentResult, DeploymentProgress&amp;gt; StagePackageAsync(Uri packageUri, IIterable&amp;lt;Uri&amp;gt; dependencyPackageUris, DeploymentOptions options, PackageVolume targetVolume, IIterable&amp;lt;string&amp;gt; optionalPackageFamilyNames, IIterable&amp;lt;Uri&amp;gt; packageUrisToInstall, IIterable&amp;lt;Uri&amp;gt; relatedPackageUris);
  }
}
namespace Windows.Media.Capture {
  public sealed class AppCapture {
    public static IAsyncAction SetAllowedAsync(bool allowed);
  }
}
namespace Windows.Media.Capture.Frames {
  public sealed class MediaFrameReader : IClosable {
    MediaFrameReaderAcquisitionMode AcquisitionMode { get; set; }
  }
  public enum MediaFrameReaderAcquisitionMode
  public sealed class MultiSourceMediaFrameReader : IClosable {
    MediaFrameReaderAcquisitionMode AcquisitionMode { get; set; }
  }
}
namespace Windows.Media.Core {
  public sealed class AudioStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    string Label { get; set; }
  }
  public interface IMediaStreamDescriptor2 : IMediaStreamDescriptor
  public sealed class InitializeMediaStreamSourceRequestedEventArgs
  public static class LowLightFusion
  public sealed class LowLightFusionResult : IClosable
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    public static MediaSource CreateFromMediaFrameSource(MediaFrameSource frameSource);
  }
  public sealed class MediaSourceAppServiceConnection
  public sealed class MediaStreamSource : IMediaSource {
    bool IsLive { get; set; }
  }
  public sealed class MseStreamSource : IMediaSource {
    IReference&amp;lt;MseTimeRange&amp;gt; LiveSeekableRange { get; set; }
  }
  public sealed class SceneAnalysisEffectFrame : IClosable, IMediaFrame {
    SceneAnalysisRecommendation AnalysisRecommendation { get; }
  }
  public enum SceneAnalysisRecommendation
  public sealed class VideoStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    string Label { get; set; }
  }
}
namespace Windows.Media.DialProtocol {
  public sealed class DialReceiverApp
}
namespace Windows.Media.MediaProperties {
  public sealed class MediaEncodingProfile {
    IVector&amp;lt;AudioStreamDescriptor&amp;gt; GetAudioTracks();
    IVector&amp;lt;VideoStreamDescriptor&amp;gt; GetVideoTracks();
    void SetAudioTracks(IIterable&amp;lt;AudioStreamDescriptor&amp;gt; value);
    void SetVideoTracks(IIterable&amp;lt;VideoStreamDescriptor&amp;gt; value);
  }
}
namespace Windows.Media.Playback {
  public sealed class MediaPlaybackSessionBufferingStartedEventArgs
  public sealed class MediaPlayer : IClosable {
    event TypedEventHandler&amp;lt;MediaPlayer, object&amp;gt; SubtitleFrameChanged;
    bool RenderSubtitlesToSurface(IDirect3DSurface destination);
    bool RenderSubtitlesToSurface(IDirect3DSurface destination, Rect targetRectangle);
  }
}
namespace Windows.Media.Protection.PlayReady {
  public enum PlayReadyEncryptionAlgorithm {
    Aes128Cbc = 5,
    Unspecified = 65535,
  }
  public enum PlayReadyHardwareDRMFeatures {
    Aes128Cbc = 3,
  }
}
namespace Windows.Media.SpeechRecognition {
  public sealed class SpeechRecognizer : IClosable {
    public static IAsyncOperation&amp;lt;bool&amp;gt; TrySetSystemSpeechLanguageAsync(Language speechLanguage);
  }
}
namespace Windows.Media.SpeechSynthesis {
  public sealed class SpeechSynthesizer : IClosable {
    public static IAsyncOperation&amp;lt;bool&amp;gt; TrySetDefaultVoiceAsync(VoiceInformation voice);
  }
  public sealed class SpeechSynthesizerOptions {
    double AudioPitch { get; set; }
    double AudioVolume { get; set; }
    double SpeakingRate { get; set; }
  }
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs {
    HResult ExtendedError { get; }
  }
  public enum AdaptiveMediaSourceDiagnosticType {
    FatalMediaSourceError = 8,
  }
}
namespace Windows.Networking.BackgroundTransfer {
  public struct BackgroundTransferFileRange
  public sealed class BackgroundTransferRangesDownloadedEventArgs
  public enum BackgroundTransferStatus {
    PausedRecoverableWebErrorStatus = 8,
  }
  public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    IReference&amp;lt;WebErrorStatus&amp;gt; CurrentWebErrorStatus { get; }
    bool IsRandomAccessRequired { get; set; }
    IVector&amp;lt;WebErrorStatus&amp;gt; RecoverableWebErrorStatuses { get; }
    Uri RequestedUri { get; set; }
    event TypedEventHandler&amp;lt;DownloadOperation, BackgroundTransferRangesDownloadedEventArgs&amp;gt; RangesDownloaded;
    IVector&amp;lt;BackgroundTransferFileRange&amp;gt; GetDownloadedRanges();
    IRandomAccessStreamReference GetResultRandomAccessStreamReference();
  }
}
namespace Windows.Networking.Connectivity {
  public sealed class ConnectionProfile {
    IAsyncOperation&amp;lt;IVectorView&amp;lt;ProviderNetworkUsage&amp;gt;&amp;gt; GetProviderNetworkUsageAsync(DateTime startTime, DateTime endTime, NetworkUsageStates states);
  }
  public sealed class ProviderNetworkUsage
}
namespace Windows.Networking.NetworkOperators {
  public sealed class MobileBroadbandAntennaSar
  public sealed class MobileBroadbandCellCdma
  public sealed class MobileBroadbandCellGsm
  public sealed class MobileBroadbandCellLte
  public sealed class MobileBroadbandCellsInfo
  public sealed class MobileBroadbandCellTdscdma
  public sealed class MobileBroadbandCellUmts
  public sealed class MobileBroadbandModem {
    IAsyncOperation&amp;lt;bool&amp;gt; GetIsPassthroughEnabledAsync();
    IAsyncOperation&amp;lt;MobileBroadbandModemStatus&amp;gt; SetIsPassthroughEnabledAsync(bool value);
  }
  public sealed class MobileBroadbandModemConfiguration {
    MobileBroadbandSarManager SarManager { get; }
  }
  public enum MobileBroadbandModemStatus
  public sealed class MobileBroadbandNetwork {
    IAsyncOperation&amp;lt;MobileBroadbandCellsInfo&amp;gt; GetCellsInfoAsync();
  }
  public sealed class MobileBroadbandSarManager
  public sealed class MobileBroadbandTransmissionStateChangedEventArgs
}
namespace Windows.Networking.Sockets {
  public sealed class MessageWebSocketControl : IWebSocketControl, IWebSocketControl2 {
    TimeSpan ActualUnsolicitedPongInterval { get; }
    Certificate ClientCertificate { get; set; }
    TimeSpan DesiredUnsolicitedPongInterval { get; set; }
    MessageWebSocketReceiveMode ReceiveMode { get; set; }
  }
  public sealed class MessageWebSocketMessageReceivedEventArgs {
    bool IsMessageComplete { get; }
  }
  public enum MessageWebSocketReceiveMode
  public enum SocketProtectionLevel {
    Unspecified = 9,
  }
  public sealed class StreamSocketControl {
    SocketProtectionLevel MinProtectionLevel { get; set; }
  }
  public sealed class StreamWebSocketControl : IWebSocketControl, IWebSocketControl2 {
    TimeSpan ActualUnsolicitedPongInterval { get; }
    Certificate ClientCertificate { get; set; }
    TimeSpan DesiredUnsolicitedPongInterval { get; set; }
  }
}
namespace Windows.Security.Authentication.Web.Provider {
  public static class WebAccountManager {
    public static IAsyncAction InvalidateAppCacheForAccountAsync(WebAccount webAccount);
    public static IAsyncAction InvalidateAppCacheForAllAccountsAsync();
  }
}
namespace Windows.Services.Maps {
  public sealed class MapRoute {
    bool IsScenic { get; }
  }
  public enum MapRouteOptimization {
    Scenic = 3,
  }
  public sealed class PlaceInfo
  public sealed class PlaceInfoCreateOptions
}
namespace Windows.Storage {
  public sealed class StorageLibrary {
    IAsyncOperation&amp;lt;bool&amp;gt; AreFolderSuggestionsAvailableAsync();
  }
  public sealed class StorageProvider {
    IAsyncOperation&amp;lt;bool&amp;gt; IsPropertySupportedForPartialFileAsync(string propertyCanonicalName);
  }
}
namespace Windows.Storage.Search {
  public enum IndexerOption {
    OnlyUseIndexerAndOptimizeForIndexedProperties = 3,
  }
}
namespace Windows.Storage.Streams {
  public enum FileOpenDisposition
  public sealed class FileRandomAccessStream : IClosable, IInputStream, IOutputStream, IRandomAccessStream {
    public static IAsyncOperation&amp;lt;IRandomAccessStream&amp;gt; OpenAsync(string filePath, FileAccessMode accessMode);
    public static IAsyncOperation&amp;lt;IRandomAccessStream&amp;gt; OpenAsync(string filePath, FileAccessMode accessMode, StorageOpenOptions sharingOptions, FileOpenDisposition openDisposition);
    public static IAsyncOperation&amp;lt;IRandomAccessStream&amp;gt; OpenForUserAsync(User user, string filePath, FileAccessMode accessMode);
    public static IAsyncOperation&amp;lt;IRandomAccessStream&amp;gt; OpenForUserAsync(User user, string filePath, FileAccessMode accessMode, StorageOpenOptions sharingOptions, FileOpenDisposition openDisposition);
    public static IAsyncOperation&amp;lt;StorageStreamTransaction&amp;gt; OpenTransactedWriteAsync(string filePath);
    public static IAsyncOperation&amp;lt;StorageStreamTransaction&amp;gt; OpenTransactedWriteAsync(string filePath, StorageOpenOptions openOptions, FileOpenDisposition openDisposition);
    public static IAsyncOperation&amp;lt;StorageStreamTransaction&amp;gt; OpenTransactedWriteForUserAsync(User user, string filePath);
    public static IAsyncOperation&amp;lt;StorageStreamTransaction&amp;gt; OpenTransactedWriteForUserAsync(User user, string filePath, StorageOpenOptions openOptions, FileOpenDisposition openDisposition);
  }
}
namespace Windows.System {
  public sealed class AppDiagnosticInfo {
    AppResourceGroupInfoWatcher CreateResourceGroupWatcher();
    public static AppDiagnosticInfoWatcher CreateWatcher();
    IVector&amp;lt;AppResourceGroupInfo&amp;gt; GetResourceGroups();
    public static IAsyncOperation&amp;lt;DiagnosticAccessStatus&amp;gt; RequestAccessAsync();
    public static IAsyncOperation&amp;lt;IVector&amp;lt;AppDiagnosticInfo&amp;gt;&amp;gt; RequestInfoForAppAsync();
    public static IAsyncOperation&amp;lt;IVector&amp;lt;AppDiagnosticInfo&amp;gt;&amp;gt; RequestInfoForAppAsync(string appUserModelId);
    public static IAsyncOperation&amp;lt;IVector&amp;lt;AppDiagnosticInfo&amp;gt;&amp;gt; RequestInfoForPackageAsync(string packageFamilyName);
  }
  public sealed class AppDiagnosticInfoWatcher
  public sealed class AppDiagnosticInfoWatcherEventArgs
  public enum AppDiagnosticInfoWatcherStatus
  public sealed class AppMemoryReport {
    ulong ExpectedTotalCommitLimit { get; }
  }
  public sealed class AppResourceGroupBackgroundTaskReport
  public enum AppResourceGroupEnergyQuotaState
  public enum AppResourceGroupExecutionState
  public sealed class AppResourceGroupInfo
  public sealed class AppResourceGroupInfoWatcher
  public sealed class AppResourceGroupInfoWatcherEventArgs
  public sealed class AppResourceGroupInfoWatcherExecutionStateChangedEventArgs
  public enum AppResourceGroupInfoWatcherStatus
  public sealed class AppResourceGroupMemoryReport
  public sealed class AppResourceGroupStateReport
  public enum DiagnosticAccessStatus
  public sealed class DispatcherQueue
  public sealed class DispatcherQueueController
  public delegate void DispatcherQueueHandler();
  public enum DispatcherQueuePriority
  public sealed class DispatcherQueueShutdownStartingEventArgs
  public sealed class DispatcherQueueTimer
  public static class MemoryManager {
    public static ulong ExpectedAppMemoryUsageLimit { get; }
  }
}
namespace Windows.System.Diagnostics {
  public sealed class DiagnosticActionResult
  public enum DiagnosticActionState
  public sealed class DiagnosticInvoker
  public sealed class ProcessDiagnosticInfo {
    bool IsPackaged { get; }
    IVector&amp;lt;AppDiagnosticInfo&amp;gt; GetAppDiagnosticInfos();
    public static ProcessDiagnosticInfo TryGetForProcessId(uint processId);
  }
}
namespace Windows.System.Profile {
  public enum SystemIdentificationSource {
    Registry = 3,
  }
}
namespace Windows.System.RemoteSystems {
  public sealed class RemoteSystem {
    string ManufacturerDisplayName { get; }
    string ModelDisplayName { get; }
  }
  public static class RemoteSystemKinds {
    public static string Iot { get; }
    public static string Laptop { get; }
    public static string Tablet { get; }
  }
}
namespace Windows.System.UserProfile {
  public static class GlobalizationPreferences {
    public static bool TrySetHomeGeographicRegion(string region);
    public static bool TrySetLanguages(IIterable&amp;lt;string&amp;gt; languageTags);
  }
}
namespace Windows.UI.Composition {
  public sealed class AmbientLight : CompositionLight {
    float Intensity { get; set; }
  }
  public class CompositionAnimation : CompositionObject, ICompositionAnimationBase {
    InitialValueExpressionCollection InitialValueExpressions { get; }
  }
  public sealed class CompositionColorGradientStop : CompositionObject
  public sealed class CompositionColorGradientStopCollection : IIterable&amp;lt;CompositionColorGradientStop&amp;gt;, IVector&amp;lt;CompositionColorGradientStop&amp;gt;
  public enum CompositionColorSpace {
    HslLinear = 3,
    RgbLinear = 4,
  }
  public enum CompositionDropShadowSourcePolicy
  public class CompositionGradientBrush : CompositionBrush
  public enum CompositionGradientExtendMode
  public class CompositionLight : CompositionObject {
    VisualUnorderedCollection ExclusionsFromTargets { get; }
  }
  public sealed class CompositionLinearGradientBrush : CompositionGradientBrush
  public class CompositionObject : IClosable {
    DispatcherQueue DispatcherQueue { get; }
  }
  public class CompositionTarget : CompositionObject {
  }
  public sealed class Compositor : IClosable {
    CompositionColorGradientStop CreateColorGradientStop();
    CompositionColorGradientStop CreateColorGradientStop(float offset, Color color);
    CompositionLinearGradientBrush CreateLinearGradientBrush();
    SpringScalarNaturalMotionAnimation CreateSpringScalarAnimation();
    SpringVector2NaturalMotionAnimation CreateSpringVector2Animation();
    SpringVector3NaturalMotionAnimation CreateSpringVector3Animation();
  }
  public sealed class DistantLight : CompositionLight {
    float Intensity { get; set; }
  }
  public sealed class DropShadow : CompositionShadow {
    CompositionDropShadowSourcePolicy SourcePolicy { get; set; }
  }
  public sealed class InitialValueExpressionCollection : CompositionObject, IIterable&amp;lt;IKeyValuePair&amp;lt;string, string&amp;gt;&amp;gt;, IMap&amp;lt;string, string&amp;gt;
  public sealed class LayerVisual : ContainerVisual {
    CompositionShadow Shadow { get; set; }
  }
  public class NaturalMotionAnimation : CompositionAnimation
  public sealed class PointLight : CompositionLight {
    float Intensity { get; set; }
  }
  public class ScalarNaturalMotionAnimation : NaturalMotionAnimation
  public sealed class SpotLight : CompositionLight {
    float InnerConeIntensity { get; set; }
    float OuterConeIntensity { get; set; }
  }
  public sealed class SpringScalarNaturalMotionAnimation : ScalarNaturalMotionAnimation
  public sealed class SpringVector2NaturalMotionAnimation : Vector2NaturalMotionAnimation
  public sealed class SpringVector3NaturalMotionAnimation : Vector3NaturalMotionAnimation
  public class Vector2NaturalMotionAnimation : NaturalMotionAnimation
  public class Vector3NaturalMotionAnimation : NaturalMotionAnimation
}
namespace Windows.UI.Composition.Effects {
  public sealed class SceneLightingEffect : IGraphicsEffect, IGraphicsEffectSource {
    SceneLightingEffectReflectanceModel ReflectanceModel { get; set; }
  }
  public enum SceneLightingEffectReflectanceModel
}
namespace Windows.UI.Composition.Interactions {
  public sealed class InteractionTracker : CompositionObject {
    void ConfigureVector2PositionInertiaModifiers(IIterable&amp;lt;InteractionTrackerVector2InertiaModifier&amp;gt; modifiers);
  }
  public sealed class InteractionTrackerInertiaNaturalMotion : InteractionTrackerInertiaModifier
  public class InteractionTrackerVector2InertiaModifier : CompositionObject
  public sealed class InteractionTrackerVector2InertiaNaturalMotion : InteractionTrackerVector2InertiaModifier
}
namespace Windows.UI.Core {
  public enum CoreCursorType {
    Person = 15,
    Pin = 14,
  }
  public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
    CoreWindowActivationMode ActivationMode { get; }
    DispatcherQueue DispatcherQueue { get; }
  }
  public enum CoreWindowActivationMode
}
namespace Windows.UI.Input {
  public sealed class RadialControllerConfiguration {
    public static RadialController AppController { get; set; }
    public static bool IsAppControllerEnabled { get; set; }
  }
}
namespace Windows.UI.Input.Inking.Core {
  public sealed class CoreIncrementalInkStroke
  public sealed class CoreInkPresenterHost
}
namespace Windows.UI.Input.Preview.Injection {
  public sealed class InjectedInputGamepadInfo
  public sealed class InputInjector {
    void InitializeGamepadInjection();
    void InjectGamepadInput(InjectedInputGamepadInfo input);
    public static InputInjector TryCreateForAppBroadcastOnly();
    void UninitializeGamepadInjection();
  }
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialInteractionController {
    IAsyncOperation&amp;lt;IRandomAccessStreamWithContentType&amp;gt; TryGetRenderableModelAsync();
  }
  public sealed class SpatialInteractionSource {
    SpatialInteractionSourceHandedness Handedness { get; }
  }
  public enum SpatialInteractionSourceHandedness
  public sealed class SpatialInteractionSourceLocation {
    IReference&amp;lt;Vector3&amp;gt; AngularVelocity { get; }
    SpatialInteractionSourcePositionAccuracy PositionAccuracy { get; }
    SpatialPointerInteractionSourcePose SourcePointerPose { get; }
  }
  public enum SpatialInteractionSourcePositionAccuracy
  public sealed class SpatialPointerInteractionSourcePose {
    Quaternion Orientation { get; }
    SpatialInteractionSourcePositionAccuracy PositionAccuracy { get; }
  }
}
namespace Windows.UI.Shell {
  public static class AdaptiveCardBuilder
  public interface IAdaptiveCard
  public interface IAdaptiveCardBuilderStatics
  public sealed class TaskbarManager
}
namespace Windows.UI.StartScreen {
  public sealed class SecondaryTileVisualElements {
    TileMixedRealityModel MixedRealityModel { get; }
  }
  public sealed class TileMixedRealityModel
}
namespace Windows.UI.Text.Core {
  public enum CoreTextInputScope {
    Digits = 28,
    PinAlphanumeric = 65,
    PinNumeric = 64,
  }
}
namespace Windows.UI.ViewManagement {
  public enum UIElementType {
    AccentColor = 1000,
    NonTextHigh = 1005,
    NonTextLow = 1009,
    NonTextMedium = 1007,
    NonTextMediumHigh = 1006,
    NonTextMediumLow = 1008,
    OverlayOutsidePopup = 1012,
    PageBackground = 1010,
    PopupBackground = 1011,
    TextContrastWithHigh = 1004,
    TextHigh = 1001,
    TextLow = 1003,
    TextMedium = 1002,
  }
}
namespace Windows.UI.ViewManagement.Core {
  public sealed class CoreInputView
  public sealed class CoreInputViewOcclusion
  public enum CoreInputViewOcclusionKind
  public sealed class CoreInputViewOcclusionsChangedEventArgs
}
namespace Windows.UI.WebUI {
  public static class WebUIApplication {
    public static IAsyncOperation&amp;lt;AppRestartFailureReason&amp;gt; RequestRestartAsync(string launchArguments);
    public static IAsyncOperation&amp;lt;AppRestartFailureReason&amp;gt; RequestRestartForUserAsync(User user, string launchArguments);
  }
  public sealed class WebUICommandLineActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, ICommandLineActivatedEventArgs
  public sealed class WebUIStartupTaskActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IStartupTaskActivatedEventArgs
}
namespace Windows.UI.Xaml {
  public class FrameworkElement : UIElement {
    ElementTheme ActualTheme { get; }
    public static DependencyProperty ActualThemeProperty { get; }
    event TypedEventHandler&amp;lt;FrameworkElement, object&amp;gt; ActualThemeChanged;
  }
  public enum TextAlignment {
    End = 2,
    Start = 1,
  }
  public class UIElement : DependencyObject {
    public static RoutedEvent CharacterReceivedEvent { get; }
    IVector&amp;lt;KeyboardAccelerator&amp;gt; KeyboardAccelerators { get; }
    public static RoutedEvent PreviewKeyDownEvent { get; }
    public static RoutedEvent PreviewKeyUpEvent { get; }
    event TypedEventHandler&amp;lt;UIElement, CharacterReceivedRoutedEventArgs&amp;gt; CharacterReceived;
    event KeyEventHandler PreviewKeyDown;
    event KeyEventHandler PreviewKeyUp;
    event TypedEventHandler&amp;lt;UIElement, ProcessKeyboardAcceleratorEventArgs&amp;gt; ProcessKeyboardAccelerators;
    virtual IIterable&amp;lt;DependencyObject&amp;gt; GetChildrenInTabFocusOrder();
    virtual void OnProcessKeyboardAccelerators(ProcessKeyboardAcceleratorEventArgs args);
    void TryInvokeKeyboardAccelerator(ProcessKeyboardAcceleratorEventArgs args);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public enum AutomationNotificationKind
  public enum AutomationNotificationProcessing
  public class AutomationPeer : DependencyObject {
    void RaiseNotificationEvent(AutomationNotificationKind notificationKind, AutomationNotificationProcessing notificationProcessing, string displayString, string activityId);
  }
  public class ColorPickerSliderAutomationPeer : SliderAutomationPeer
  public class ColorSpectrumAutomationPeer : FrameworkElementAutomationPeer
  public class NavigationViewItemAutomationPeer : ListViewItemAutomationPeer
  public class PersonPictureAutomationPeer : FrameworkElementAutomationPeer
  public class RatingControlAutomationPeer : FrameworkElementAutomationPeer
  public class TreeViewItemAutomationPeer : ListViewItemAutomationPeer
  public class TreeViewListAutomationPeer : SelectorAutomationPeer
}
namespace Windows.UI.Xaml.Controls {
  public class BitmapIconSource : IconSource
  public enum CharacterCasing
  public sealed class ColorChangedEventArgs
  public class ColorPicker : Control
  public enum ColorPickerHsvChannel
  public enum ColorSpectrumComponents
  public enum ColorSpectrumShape
  public class ComboBox : Selector {
    Brush PlaceholderForeground { get; set; }
    public static DependencyProperty PlaceholderForegroundProperty { get; }
  }
  public class ContentDialog : ContentControl {
    IAsyncOperation&amp;lt;ContentDialogResult&amp;gt; ShowAsync(ContentDialogPlacement placement);
  }
  public enum ContentDialogPlacement
  public class Control : FrameworkElement {
    virtual void OnCharacterReceived(CharacterReceivedRoutedEventArgs e);
    virtual void OnPreviewKeyDown(KeyRoutedEventArgs e);
    virtual void OnPreviewKeyUp(KeyRoutedEventArgs e);
  }
  public enum DisabledFormattingAccelerators : uint
  public class FontIconSource : IconSource
  public class Grid : Panel {
    double ColumnSpacing { get; set; }
    public static DependencyProperty ColumnSpacingProperty { get; }
    double RowSpacing { get; set; }
    public static DependencyProperty RowSpacingProperty { get; }
  }
  public class IconSource : DependencyObject
  public sealed class IsTextTrimmedChangedEventArgs
  public class MediaTransportControls : Control {
    bool IsRepeatButtonVisible { get; set; }
    public static DependencyProperty IsRepeatButtonVisibleProperty { get; }
    bool IsRepeatEnabled { get; set; }
    public static DependencyProperty IsRepeatEnabledProperty { get; }
    bool ShowAndHideAutomatically { get; set; }
    public static DependencyProperty ShowAndHideAutomaticallyProperty { get; }
    void Hide();
    void Show();
  }
  public class NavigationView : ContentControl
  public enum NavigationViewDisplayMode
  public sealed class NavigationViewDisplayModeChangedEventArgs
  public class NavigationViewItem : NavigationViewItemBase
  public class NavigationViewItemBase : ListViewItem
  public class NavigationViewItemHeader : NavigationViewItemBase
  public sealed class NavigationViewItemInvokedEventArgs
  public class NavigationViewItemSeparator : NavigationViewItemBase
  public class NavigationViewList : ListView
  public sealed class NavigationViewSelectionChangedEventArgs
  public enum ParallaxSourceOffsetKind
  public class ParallaxView : FrameworkElement
  public sealed class PasswordBox : Control {
    event TypedEventHandler&amp;lt;PasswordBox, PasswordBoxPasswordChangingEventArgs&amp;gt; PasswordChanging;
  }
  public sealed class PasswordBoxPasswordChangingEventArgs
  public class PathIconSource : IconSource
  public class PersonPicture : Control
  public class RatingControl : Control
  public class RatingItemFontInfo : RatingItemInfo
  public class RatingItemImageInfo : RatingItemInfo
  public class RatingItemInfo : DependencyObject
  public class RichEditBox : Control {
    CharacterCasing CharacterCasing { get; set; }
    public static DependencyProperty CharacterCasingProperty { get; }
    DisabledFormattingAccelerators DisabledFormattingAccelerators { get; set; }
    public static DependencyProperty DisabledFormattingAcceleratorsProperty { get; }
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    event TypedEventHandler&amp;lt;RichEditBox, TextControlCopyingToClipboardEventArgs&amp;gt; CopyingToClipboard;
    event TypedEventHandler&amp;lt;RichEditBox, TextControlCuttingToClipboardEventArgs&amp;gt; CuttingToClipboard;
  }
  public sealed class RichTextBlock : FrameworkElement {
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    bool IsTextTrimmed { get; }
    public static DependencyProperty IsTextTrimmedProperty { get; }
    IVector&amp;lt;TextHighlighter&amp;gt; TextHighlighters { get; }
    event TypedEventHandler&amp;lt;RichTextBlock, IsTextTrimmedChangedEventArgs&amp;gt; IsTextTrimmedChanged;
  }
  public sealed class RichTextBlockOverflow : FrameworkElement {
    bool IsTextTrimmed { get; }
    public static DependencyProperty IsTextTrimmedProperty { get; }
    event TypedEventHandler&amp;lt;RichTextBlockOverflow, IsTextTrimmedChangedEventArgs&amp;gt; IsTextTrimmedChanged;
  }
  public class SplitView : Control {
    event TypedEventHandler&amp;lt;SplitView, object&amp;gt; PaneOpened;
    event TypedEventHandler&amp;lt;SplitView, object&amp;gt; PaneOpening;
  }
  public class StackPanel : Panel, IInsertionPanel, IScrollSnapPointsInfo {
    double Spacing { get; set; }
    public static DependencyProperty SpacingProperty { get; }
  }
  public enum SwipeBehaviorOnInvoked
  public class SwipeControl : ContentControl
  public class SwipeItem : DependencyObject
  public sealed class SwipeItemInvokedEventArgs
  public class SwipeItems : DependencyObject, IIterable&amp;lt;SwipeItem&amp;gt;, IVector&amp;lt;SwipeItem&amp;gt;
  public enum SwipeMode
  public enum Symbol {
    GlobalNavigationButton = 59136,
    Print = 59209,
    Share = 59181,
    XboxOneConsole = 59792,
  }
  public class SymbolIconSource : IconSource
  public sealed class TextBlock : FrameworkElement {
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    bool IsTextTrimmed { get; }
    public static DependencyProperty IsTextTrimmedProperty { get; }
    IVector&amp;lt;TextHighlighter&amp;gt; TextHighlighters { get; }
    event TypedEventHandler&amp;lt;TextBlock, IsTextTrimmedChangedEventArgs&amp;gt; IsTextTrimmedChanged;
  }
  public class TextBox : Control {
    CharacterCasing CharacterCasing { get; set; }
    public static DependencyProperty CharacterCasingProperty { get; }
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
    Brush PlaceholderForeground { get; set; }
    public static DependencyProperty PlaceholderForegroundProperty { get; }
    event TypedEventHandler&amp;lt;TextBox, TextBoxBeforeTextChangingEventArgs&amp;gt; BeforeTextChanging;
    event TypedEventHandler&amp;lt;TextBox, TextControlCopyingToClipboardEventArgs&amp;gt; CopyingToClipboard;
    event TypedEventHandler&amp;lt;TextBox, TextControlCuttingToClipboardEventArgs&amp;gt; CuttingToClipboard;
  }
  public sealed class TextBoxBeforeTextChangingEventArgs
  public sealed class TextControlCopyingToClipboardEventArgs
  public sealed class TextControlCuttingToClipboardEventArgs
  public class TreeView : Control
  public sealed class TreeViewExpandingEventArgs
  public class TreeViewItem : ListViewItem
  public sealed class TreeViewItemClickEventArgs
  public class TreeViewList : ListView
  public class TreeViewNode : DependencyObject, IBindableIterable, IBindableObservableVector, IBindableVector
  public enum TreeViewSelectionMode
  public sealed class XamlBooleanToVisibilityConverter : IValueConverter
  public sealed class XamlIntegerToIndentationConverter : IValueConverter
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControl : Control {
    IVector&amp;lt;MapLayer&amp;gt; Layers { get; set; }
    public static DependencyProperty LayersProperty { get; }
    bool TryGetLocationFromOffset(Point offset, AltitudeReferenceSystem desiredReferenceSystem, out Geopoint location);
    bool TryGetLocationFromOffset(Point offset, out Geopoint location);
  }
  public class MapElement : DependencyObject {
    string MapStyleSheetEntry { get; set; }
    public static DependencyProperty MapStyleSheetEntryProperty { get; }
    string MapStyleSheetEntryState { get; set; }
    public static DependencyProperty MapStyleSheetEntryStateProperty { get; }
    object Tag { get; set; }
    public static DependencyProperty TagProperty { get; }
  }
  public sealed class MapElement3D : MapElement
  public sealed class MapElementsLayer : MapLayer
  public sealed class MapElementsLayerClickEventArgs
  public sealed class MapElementsLayerContextRequestedEventArgs
  public sealed class MapElementsLayerPointerEnteredEventArgs
  public sealed class MapElementsLayerPointerExitedEventArgs
  public class MapLayer : DependencyObject
  public class MapModel3D : DependencyObject
  public enum MapModel3DShadingOption
  public static class MapStyleSheetEntries
  public static class MapStyleSheetEntryStates
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public class ColorPickerSlider : Slider
  public class ColorSpectrum : Control
  public class FlyoutBase : DependencyObject {
    virtual void OnProcessKeyboardAccelerators(ProcessKeyboardAcceleratorEventArgs args);
    void TryInvokeKeyboardAccelerator(ProcessKeyboardAcceleratorEventArgs args);
  }
  public sealed class LayoutInformation {
    public static Size GetAvailableSize(UIElement element);
  }
  public class ListViewItemPresenter : ContentPresenter {
    Brush RevealBackground { get; set; }
    public static DependencyProperty RevealBackgroundProperty { get; }
    bool RevealBackgroundShowsAboveContent { get; set; }
    public static DependencyProperty RevealBackgroundShowsAboveContentProperty { get; }
    Brush RevealBorderBrush { get; set; }
    public static DependencyProperty RevealBorderBrushProperty { get; }
    Thickness RevealBorderThickness { get; set; }
    public static DependencyProperty RevealBorderThicknessProperty { get; }
  }
}
namespace Windows.UI.Xaml.Data {
  public enum UpdateSourceTrigger {
    LostFocus = 3,
  }
}
namespace Windows.UI.Xaml.Documents {
  public class Block : TextElement {
    TextAlignment HorizontalTextAlignment { get; set; }
    public static DependencyProperty HorizontalTextAlignmentProperty { get; }
  }
  public sealed class Hyperlink : Span {
    bool IsTabStop { get; set; }
    public static DependencyProperty IsTabStopProperty { get; }
    int TabIndex { get; set; }
    public static DependencyProperty TabIndexProperty { get; }
  }
  public class TextHighlighter
  public class TextHighlighterBase : DependencyObject
  public struct TextRange
}
namespace Windows.UI.Xaml.Input {
  public sealed class CharacterReceivedRoutedEventArgs : RoutedEventArgs
  public class KeyboardAccelerator : DependencyObject
  public sealed class KeyboardAcceleratorInvokedEventArgs
  public sealed class PointerRoutedEventArgs : RoutedEventArgs {
    bool IsGenerated { get; }
  }
  public sealed class ProcessKeyboardAcceleratorEventArgs
}
namespace Windows.UI.Xaml.Markup {
  public class MarkupExtension
  public sealed class MarkupExtensionReturnTypeAttribute : Attribute
}
namespace Windows.UI.Xaml.Media {
  public enum AcrylicBackgroundSource
  public class AcrylicBrush : XamlCompositionBrushBase
  public class RevealBackgroundBrush : RevealBrush
  public class RevealBorderBrush : RevealBrush
  public class RevealBrush : XamlCompositionBrushBase
  public enum RevealBrushState
}
namespace Windows.Web {
  public enum WebErrorStatus {
    InsufficientRangeSupport = 22,
    MissingContentLengthSupport = 23,
  }
}
 
namespace Windows.Gaming.Preview.GamesEnumeration {
  public static class GameList {
    public static IAsyncOperation&amp;lt;GameListEntry&amp;gt; MergeEntriesAsync(GameListEntry left, GameListEntry right);
    public static IAsyncOperation&amp;lt;IVectorView&amp;lt;GameListEntry&amp;gt;&amp;gt; UnmergeEntryAsync(GameListEntry mergedEntry);
  }
  public sealed class GameListEntry : IGameListEntry {
    GameModeConfiguration GameModeConfiguration { get; }
    GameListEntryLaunchableState LaunchableState { get; }
    IStorageFile LauncherExecutable { get; }
    string LaunchParameters { get; }
    string TitleId { get; }
    IAsyncAction SetLauncherExecutableFileAsync(IStorageFile executableFile);
    IAsyncAction SetLauncherExecutableFileAsync(IStorageFile executableFile, string launchParams);
    IAsyncAction SetTitleIdAsync(string id);
  }
  public enum GameListEntryLaunchableState
  public sealed class GameModeConfiguration
  public sealed class GameModeUserConfiguration
}
namespace Windows.Graphics.Printing3D {
  public sealed class Printing3D3MFPackage {
    Printing3DPackageCompression Compression { get; set; }
  }
  public enum Printing3DPackageCompression
}
namespace Windows.Media.Capture {
  public sealed class AppBroadcastBackgroundService {
    string BroadcastChannel { get; set; }
    string BroadcastLanguage { get; set; }
    string BroadcastTitle { get; set; }
    event TypedEventHandler&amp;lt;AppBroadcastBackgroundService, object&amp;gt; BroadcastChannelChanged;
    event TypedEventHandler&amp;lt;AppBroadcastBackgroundService, object&amp;gt; BroadcastLanguageChanged;
    event TypedEventHandler&amp;lt;AppBroadcastBackgroundService, object&amp;gt; BroadcastTitleChanged;
  }
  public sealed class AppBroadcastBackgroundServiceSignInInfo {
    event TypedEventHandler&amp;lt;AppBroadcastBackgroundServiceSignInInfo, object&amp;gt; UserNameChanged;
  }
  public sealed class AppBroadcastBackgroundServiceStreamInfo {
    void ReportProblemWithStream();
  }
}
namespace Windows.Security.EnterpriseData {
  public sealed class FileProtectionInfo {
    bool IsProtectWhileOpenSupported { get; }
  }
}
namespace Windows.Services.Maps.Guidance {
  public sealed class GuidanceRoadSegment {
    bool IsScenic { get; }
  }
}
namespace Windows.Services.Maps.LocalSearch {
  public static class PlaceInfoHelper
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControlDataHelper : DependencyObject {
    public static MapControl CreateMapControl(bool rasterRenderMode);
  }
}
namespace Windows.System.Profile.SystemManufacturers {
  public sealed class OemSupportInfo
  public static class SystemSupportInfo
}
namespace Windows.System {
  public static class DateTimeSettings
}
namespace Windows.UI.Xaml.Hosting {
  public sealed class DesignerAppExitedEventArgs
  public sealed class DesignerAppManager : IClosable
  public sealed class DesignerAppView : IClosable
  public enum DesignerAppViewState
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    bool IsPrimaryLayerEnabled { get; set; }
    uint MaxQuadLayerCount { get; }
    IVector&amp;lt;HolographicQuadLayer&amp;gt; QuadLayers { get; }
  }
  public sealed class HolographicCameraRenderingParameters {
    bool IsContentProtectionEnabled { get; set; }
  }
  public sealed class HolographicFrame {
    HolographicQuadLayerUpdateParameters GetQuadLayerUpdateParameters(HolographicQuadLayer layer);
  }
  public sealed class HolographicQuadLayer : IClosable
  public sealed class HolographicQuadLayerUpdateParameters
}
namespace Windows.UI.Input.Spatial {
  public enum SpatialInteractionSourceHandedness {
    Unspecified = 0,
  }
  public sealed class SpatialInteractionSourceLocation {
    SpatialInteractionSourcePositionAccuracy PositionAccuracy { get; }
  }
  public enum SpatialInteractionSourcePositionAccuracy
  public sealed class SpatialPointerInteractionSourcePose {
    SpatialInteractionSourcePositionAccuracy PositionAccuracy { get; }
  }
}
namespace Windows.UI.Xaml.Hosting {
  public sealed class DesignerAppExitedEventArgs
  public sealed class DesignerAppManager : IClosable
  public sealed class DesignerAppView : IClosable
  public enum DesignerAppViewState
  public struct HostingContract
  public interface IXamlUIPresenterHost
  public interface IXamlUIPresenterHost2
  public interface IXamlUIPresenterHost3
  public sealed class XamlUIPresenter
}
 

API Removals


namespace Windows.UI.Composition {
  public sealed class CompositionTarget : CompositionObject {
  }
}

namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    PresentationLayerDrmMode DrmMode { get; set; }
    PresentationLayerConfig CreateLayerConfig();
    PresentationLayers GetPresentationLayers();
    void SetLayerConfig(PresentationLayerConfig layerConfig);
  }
  public sealed class HolographicCameraRenderingParameters {
    PresentationLayerRenderingParametersQuad GetPresentationLayerRenderingParameters(PresentationLayerQuad layer);
  }
  public sealed class PresentationLayerConfig
  public enum PresentationLayerDrmMode
  public sealed class PresentationLayerQuad
  public sealed class PresentationLayerReference
  public sealed class PresentationLayerRenderingParametersQuad
  public sealed class PresentationLayers
  public sealed class PresentationLayerSettings
  public enum PresentationLayerType
}
 
namespace Windows.UI.Input.Spatial {
  public enum SpatialInteractionSourceHandedness {
    Both = 3,
    Unknown = 0,
  }
 
  public sealed class SpatialInteractionSourceLocation {
    SpatialInteractionSourcePositionQuality PositionQuality { get; }
  }
 
  public enum SpatialInteractionSourcePositionQuality
  public sealed class SpatialPointerInteractionSourcePose {
    SpatialInteractionSourcePositionQuality PositionQuality { get; }
  }
}

Announcing more updates to Paint 3D: Magic select enhancements & drawing tools

Creating 3D art with the Magic Select tool in Paint 3D

The Paint 3D app is a 3D creation app on Windows 10 that makes it easy to create anything in 3D, whether you draw from scratch or pull from our online 3D community, Remix 3D. Since the release of Paint 3D as part of the Windows 10 Creators Update earlier this year, we’ve been listening to feedback from our fans to improve the experience and bring you the features you want. Today, we’re excited to announce updates based on that feedback to further empower the creator in everyone.

First, we’ve made editing and personalizing your creations even easier with improvements to the popular magic select tool, which instantly lets you crop the background of any picture to turn into a sticker or wrap onto a 3D object.

Second, we’re bringing one of the most popular features from MS Paint to Paint 3D, the ability to draw and create shapes with the straight line and curve tools to Paint 3D. No need for impossibly steady hands!

Let’s take a closer look at these new features:

Updates to magic select

Magic select is an amazingly powerful tool that lets you instantly crop out the background of any picture.

Family photo being cropped with Magic Select tool in Paint 3D

One of the most common uses is to “lift” a person or object out of one image for use in another scene – think a family picture, or the family pet – to personalize your 3D creations.

Family photo being cropped with Magic Select tool in Paint 3D

You can even turn the flat picture into a sticker or wrap it onto a 3D object. As of today, you can now magic select content directly into a scene, even after the scene has been partially composed so there is no need to move the object off canvas first.

Line and Curve Tools

Line and Curve Tools in Paint 3D creating a pink rose

Starting today, we have simplified the process of drawing and creating shapes with the straight line and curve tool – by bringing a key feature from MS Paint to Paint 3D. This will help you create perfect lines and curves with a few simple clicks. We added the straight line and curved line tools alongside other 2D shapes in the ‘Stickers’ menu.

The Line tool gives you the ability to control the thickness and opacity and the Curve tool has one, two, and three inflection point controls that allow for the creation of lots of interesting objects. When you use these tools across 3D shapes, the line and curve tools act just like other stickers, which means that they can be seamlessly applied to both the canvas and 3D objects.

Paint 3D also now supports a new industry-wide open standard for 3D file sharing called GLB, a part of gLTF (GL Transmission Format). This allows for faster and more efficient transfer of 3D assets by outputting only one container for all assets, minimizing the file size and the ability to use the files across other programs as a universal format.

To check out these new features for yourself, you can get started by opening the Paint 3D app.

Whether you’re an artist or just want to try out these new features for the first time, Paint 3D makes it easy to unlock your creativity and bring your ideas to life. To check out these new features for yourself, you can get started by opening the Paint 3D app. If you’re new to Paint 3D, check out this blog post on tips for getting started with Paint 3D!

Lastly, we want to hear from you! We’ve got more updates coming but hearing our feedback is what inspires us to deliver the best experience possible. Use our feedback hub in settings in Paint 3D to share your thoughts!

Windows 10 Tip: Five ways to get started with Paint 3D

Windows 10 Tip: How to get started viewing and streaming with Mixer

Mixer is the only next-gen live game streaming service that offers viewers real-time influence and participation in game streams. Mixer’s streaming protocol delivers content with less than one second of latency. It makes game streams so fast and clear, that it’s a refreshing surprise to both streamers and viewers—almost like they’re in the same room! Here’s how to get started with Mixer:

To view Mixer content from your PC, simply navigate to Mixer.com

To view Mixer content from your PC, simply navigate to Mixer.com. 

Featured streams are available right from the homepage, or you can sort streams by game using the “Games” menu on the left-hand side of the homepage.

While you’re there, consider logging in with your Microsoft account so that you can start earning sparks when you view Mixer streams across both Windows and Xbox One devices.  Sparks are in-app currency you use to interact with streamers in ways they’ve setup (like soundboards!).

To log in to Mixer with your Microsoft Account:

Login to Mixer with your Microsoft Account

  • Click “Log In” in the top right corner of the window.
  • In the Log In menu, select “Log in with Your Microsoft Account”
  • In the popup, complete the log in steps using your Microsoft account and password.

You should now see your Microsoft account profile photo in the top right corner of the Window.

To start broadcasting a Mixer stream of your own:

To set more detailed settings for your future broadcasts, select the Start button, then Settings > Gaming > Broadcasting. 

  • Launch a game.
  • Press Windows logo key + G on your Windows 10 PC to open the Game bar.
  • Press the Broadcast button to choose how you want your broadcast to look.
  • Press Start broadcasting to broadcast your game.

To set more detailed settings for your future broadcasts, select the Start button, then Settings > Gaming > Broadcasting.  Additional settings can be accessed by visiting your channel on Mixer.com.

Enable Video on Demand (VoD) for your streaming sessions:

A Video on Demand (VoD) is a recording of a previous stream that is automatically saved on Mixer. VoD recording must be enabled with the “Keep recordings [VoDs] of my streams” option on your “Manage Channel” page of Mixer.com before your stream starts for the VoD to be saved (VoD recording is disabled by default).

  • In a web browser, navigate to Mixer.com and log in.
  • Click your profile photo in the top right, then click on “Manage Channel” in the menu.
  • Select the button for “Keep recordings (VoDs) of my streams” in the preferences menu.
  • Once enabled, any broadcast longer than 5 minutes will be automatically saved as a VoD.

You can watch, download, and delete saved VoDs from your “Manage Channel” page on Mixer.com. Don’t forget you can read all of our Windows 10 Tips right over here.

Have a great week!

Announcing UWP Community Toolkit 1.5

Today marks the sixth release of the UWP Community Toolkit – all packages are updated to version 1.5. Thanks to the UWP developer community, the UWP Community Toolkit has seen great improvements and stability to the existing controls and services. The community partnership has led to several new additions to this release.

To highlight a few of the new additions, the UWP Community Toolkit now includes:

  1. Menu: A classic control used by traditional desktop applications, adapted for the Universal Windows Platform. As requested by the community on UserVoice, the Menu allows the developer to provide a hierarchical list of menus and submenus that support any input modality and can adapt to the screen size to provide a natural and fluid interaction.
  2. OrbitView: A new ItemsControl that arranges elements around a center element and provides flexibility for size and distance for each element, as well as the ability to show orbits or anchors for each item.
  3. RadialProgressBar: A XAML Control that displays a value within a range using a circular sector that grows clockwise until it becomes a full ring. A fantastic variation of the ProgressBar.
  4. RoundImageEx: Similar to the ImageEx control, the RoundImageEx control downloads and locally caches images asynchronously while showing loading indicators. In addition, the RoundImageEx allows images to be clipped as circles.
  5. ExpressionBuilder: A type-safe way to build powerful composition ExpressionAnimation.
  6. BluetoothLEHelper: The BluetoothLEHelper class provides functionality to easily enumerate, connect to and interact with Bluetooth LE Peripherals.

For a complete overview of what’s new in version 1.5, please read our release notes on GitHub.

The release of Windows 10 Creators Update (build 10.0.15063) has enabled several new APIs that make it possible to improve several controls used in apps targeting the latest update. Therefore, several packages are now targeting the Windows 10 Creators Update and can take advantage of these new APIs. We encourage all developers using the toolkit to update their apps to the latest version of the UWP Community Toolkit.

As a reminder, the UWP Community Toolkit can be used in any UWP app across PC, Xbox One, mobile, HoloLens and Surface Hub devices. You can get started by following this tutorial, or preview the latest features by installing the UWP Community Toolkit Sample App from the Windows Store.

If you would like to contribute, please join us on GitHub!

Smooth Interaction and Motion with the Visual Layer in Windows 10 Creators Update

The Composition APIs come with a robust animation engine that provides quick and fluid motion running in a separate process from your Universal Windows Platform (UWP) app. This ensures a consistent 60 frames per second when running your app on an IoT device as well as on a screaming gaming machine. It is, quite simply, fast. This is an essential capability for implementing the Fluent Design System which calls on us to create a sense of cinematic motion in our UWP apps.

The Composition APIs also provide something you probably have never had access to before: the ability to create high-performing, low-level manipulation-driven custom animations like the one shown above.  In the same way that we that want our visuals to be fast and smooth, we want our touch interactions to be sticky and responsive. Moving a visual with a finger or a digital pen should result in the visual element clinging to us no matter how fast we push and pull it across the display.

Even if a motion looks good, it also needs to feel good under the finger. It needs to maintain the illusion that we are interacting with a real object. It ought to possess the proper physics so that when we drag a visual across the screen and let go, it continues with the proper inertial movement. Similarly, user controls should provide the right amount of resistance when we pull and release them.

A fast and fluid animation system

The Visual Layer supports both keyframe animations as well as expression animations. If you have worked with XAML animations before, then you are probably already familiar with how keyframes work. In a keyframe animation, you set values for some property you want to change over time and also assign the duration for the change: in the example below, a start value, a middle value and then an ending value. The animation system will take care of tweening your animation – in other words, generating all the values between the ones you have explicitly specified based on the easing function you select. Whether Linear, or a Cubic Bezier, the animation system will use that to determine the values when interpolating.


CubicBezierEasingFunction cubicBezier = _compositor.CreateCubicBezierEasingFunction(new Vector2(.17f, .67f), new Vector2(1f, 1f));
ScalarKeyFrameAnimation blurAnimation = _compositor.CreateScalarKeyFrameAnimation();
blurAnimation.InsertKeyFrame(0.0f, 0.0f);
blurAnimation.InsertKeyFrame(0.5f, 100.0f);
blurAnimation.InsertKeyFrame(1.0f, 0.0f);
blurAnimation.Duration = TimeSpan.FromSeconds(4);
blurAnimation.IterationBehavior = AnimationIterationBehavior.Forever;
_brush.StartAnimation(&amp;quot;Blur.BlurAmount&amp;quot;, blurAnimation);

A keyframe animation is a fire-and-forget mechanism that is time based. There are situations, however, when you need your animations to be coordinated and driving each other instead of simply moving in synchronized fashion.

In the animation above (source code), each gray gear is animated based on the animation of the gear preceding it. If the preceding gear suddenly goes faster or reverses direction, it forces the following gear to do the same. Keyframe animations can’t create motion effects that work in this way, but expression animations can. They are able to do so because, while keyframe animations are time based, expression animations are reference based.

The critical code that hooks up the gears for animation is found in the following code sample, which uses the new Expression Builder Library—an open source component released alongside of the Creators Update to construct expression animations. The expression below says that the animation should reference and be driven by the RotationAngleInDegrees property of the Visual that is indicated by the parameter “previousGear”. In the next line, the current Visual’s RotationAngleInDegrees property is finally animated based on the value referred to in an expression.


private void ConfigureGearAnimation(Visual currentGear, Visual previousGear)
{
    // If rotation expression is null then create an expression of a gear rotating the opposite direction

    var _rotateExpression = previousGear.GetReference().RotationAngleInDegrees;

    // Start the animation based on the Rotation Angle in Degrees.
    currentGear.StartAnimation(&amp;quot;RotationAngleInDegrees&amp;quot;, _rotateExpression);
}

But if an animation can be driven by another animation, you may be wondering, couldn’t we also drive an animation with something more concrete like user input? Why, yes. Yes, we can.

The beauty of the ScrollViewer ManipulationPropertySet

Driving an animation from a ScrollViewer using XAML-Composition interop is fairly easy. With just a few lines of code, you can enhance the visuals of a pre-existing ScrollViewer control with a CompositionAnimation by taking advantage of the GetScrollViewerManipulationPropertySet method on the ElementCompositionPreview class. Using an animation expression, you can tie your animation to the Position of your ScrollViewer component.

You would use this technique if you wanted to add a parallax effect to your XAML or to create a sticky header that stays in place as content scrolls beneath it. In the demo illustrated below (source code), a ScrollViewer is even used to drive a parallax effect on a ListView.

Adding parallax behavior to a XAML page can be accomplished in just a few lines.


// Note: We're not using the ScrollViewer's offset values directly. Instead, we use this PropertySet which holds the position values of the ScrollViewer in real-time.
var scrollPropSet = _scrollProperties.GetSpecializedReference&amp;lt;ManipulationPropertySetReferenceNode&amp;gt;();
var startOffset = ExpressionValues.Constant.CreateConstantScalar(&amp;quot;startOffset&amp;quot;, 0.0f);
var parallaxValue = 0.5f;
var itemHeight = 0.0f;
var parallax = (scrollPropSet.Translation.Y + startOffset - (0.5f * itemHeight));
_parallaxExpression = parallax * parallaxValue - parallax;
_parallaxExpression.SetScalarParameter(&amp;quot;StartOffset&amp;quot;, (float)args.ItemIndex * visual.Size.Y / 4.0f);
visual.StartAnimation(&amp;quot;Offset.Y&amp;quot;, _parallaxExpression);

The even more beautiful InteractionTracker

Driving expression animations with a ScrollViewer is extremely powerful, but what if you want to drive animations using touch gestures that aren’t limited to a pan/zoom gesture? Additionally, when using the ScrollViewer’s manipulations, your animations are linked to the UI thread responsiveness and can lose that buttery-smooth feel when the UI thread gets bogged down.

What if you want to pull items toward you with your finger, as in the demo below (source code), or animate multiple flying images across and into the screen as happens in the demo at the top of this post (source code)?

In order to achieve these effects, you would use the new InteractionTracker and VisualInteractionSource classes. InteractionTracker is a state machine that can be driven by active input. InteractionTracker also maintains a series of properties like Position and ScalePosition as part of maintaining the state. This is what you hook up to your animations. The VisualInteractionSource class, on the other hand, determines what kind of input you will use to drive your InteractionTracker and also when to start handling input (touch in particular).

The following sample code demonstrates a basic implementation of an InteractionTracker. The viewportVisual is simply the backing Visual for the root element on the page. You use this as the VisualInteractionSource for the tracker. In doing so, you specify that you are tracking X and Y manipulations. You also indicate that you want to track inertial movement.


_tracker = InteractionTracker.Create(_compositor);

var interactionSource = VisualInteractionSource.Create(viewportVisual);

interactionSource.PositionXSourceMode = InteractionSourceMode.EnabledWithInertia;
interactionSource.PositionYSourceMode = InteractionSourceMode.EnabledWithInertia;

_tracker.InteractionSources.Add(interactionSource);

Hooking the tracker up to an expression animation works basically the same way as hooking up a gear Visual to another gear Visual, as you did earlier. You call the CreateExpressionAnimation factory method on the current Compositor and reference the Position property of the tracker.


ar positionExpression = _compositor.CreateExpressionAnimation(&amp;quot;-tracker.Position&amp;quot;);
positionExpression.SetReferenceParameter(&amp;quot;tracker&amp;quot;, _tracker);

contentVisual.StartAnimation(&amp;quot;Offset&amp;quot;, positionExpression);

This code uses the InteractionTracker’s position to produce a smooth animation for the Offset of the Visual. You can also power your Blur and Opacity animations for your other Visuals as well. This will have a result where all three animations work together, with values based on how far the user dragged their finger, to result in an amazingly fluid visual experience. Run the demo and try it for yourself (source code).

Those are the basics of driving any animation from any input. What you do with this amazing new power is entirely up to you.

Wrapping up

Expression animations and Visual Layer Interactions are both topics that can become very deep very fast. To help you through these deeper waters, we highly recommend the following videos and articles: