Category Archives: PC

Auto Added by WPeMatico

How to watch the Age of Empires: Definitive Edition Mixer Livestream on Feb. 19

How to watch the Age of Empires: Definitive Edition Mixer Livestream on Feb. 19
Tweet This

The Definitive Edition of the original Age of Empires with the Rise of Rome expansion pack is launching on Feb. 20, local time for Windows 10 PCs! To mark the occasion, the flagship Microsoft Store in New York is hosting a special livestream from the Mixer NYC Studio on Feb. 19, so fans around the world can experience the action. Join hosts Kate Yeager, Adam Isgreen from Microsoft Studios, Bert Beeckman from Forgotten Empires and more special guests as they discuss the remastering of the classic real-time strategy game, stream gameplay and share their best tips and tricks.
You’ll be able to get the game from the Microsoft Store on Windows 10 beginning at midnight on Feb. 20!

Hey Cortana, turn up the heat; Cortana now works with more smart home providers and IFTTT

Cortana helps make your life easier by making it easy to control your smart home devices from afar. Rush out of the house and forget to turn off the lights? No problem, just pull out your phone, open the Cortana app and say, “Hey Cortana, turn off the lights,” and she’ll take care of it for you.
Last October we announced you could use Cortana to manage your smart devices through Samsung SmartThings, Nest, Philips Hue, Wink, and Insteon. Today, we are pleased to announce that you can use Cortana to control your favorite smart home devices from ecobee, Honeywell Lyric, Honeywell Total Connect Comfort, LIFX, TP-Link Kasa, and Geeni. You can control these devices using Cortana on Windows 10, iPhone, Android, and the Harman Kardon Invoke speaker.
Want to come home to a warm house from a long day at work? Just tap Cortana on your PC and say “Hey Cortana, set the living room thermostat to 72 degrees” to control your ecobee, Honeywell Lyric, or Honeywell Total Connect Comfort thermostat. With vivid colors from your LIFX Wi-Fi connected light bulbs, you can set the mood just right for movie night.
With the slim smart plugs by TP-Link, you’ll never have to worry again about leaving the house and forgetting to turn off something like a space heater or straightening iron. Just say, “Hey Cortana, turn off the space heater.”
Geeni’s smart bulbs and power products work with Cortana, and its smart surge protector even lets you name and control each outlet separately or in groups with Cortana. For example, if you have several lamps in your living room, plug them into your Geeni surge protector and say, “Hey Cortana, turn off the living room lamps”, and Cortana will turn off all the outlets named “living room lamp”.
To set up your connected home with Cortana, open Cortana on Windows 10 or go to the Cortana app on your phone, click Notebook, then click Connected Home. From there, you can connect your favorite smart home accounts and control your devices from anywhere you use Cortana.*
Cortana now works with hundreds of services on IFTTT
We are also excited to share that starting today, Cortana works with IFTTT! IFTTT is a free platform that helps you connect your apps and services together. IFTTT works with 600 services from providers in a variety of areas. You could add items to your shopping list on Trello, post a tweet, open your Link shades, extend tumble time on your GE Dryer and log your weight on Fitbit among many other things. There’s a whole world of possibilities with Cortana on IFTTT.
Using IFTTT, you will be able to customize your experience by creating your own phrases to use with services on IFTTT. For example, you could turn your lights off by saying, “Hey Cortana, let there be light” or put money towards that next concert trip on Qapital by saying, “Hey Cortana, penny for my thoughts.” Use triggers and responses on IFTTT to make Cortana your truly personal assistant.
You can also use Applets on IFTTT with Cortana to trigger multiple actions with one phrase. So if you are watching a movie at home, you can say “Hey Cortana, movie time” and she’ll turn down your Hue lights, Harmony TV turned on, and your Nest Thermostat set to the right temperature.
Cortana is always available to help you on Windows 10, Android, iPhone, and Harman Kardon Invoke devices. Set up your Cortana Applets on the Cortana channel on IFTTT!

Hey Cortana, turn up the heat; Cortana now works with more smart home providers and IFTTT
Tweet This

*Additional requirements may apply per device.

Updated Microsoft Store App Developer Agreement and Microsoft Store Policies

The Microsoft Store team has updated the Microsoft Store App Developer Agreement and Microsoft Store Policies as of February 14th.  
The new version (8.2) of the Microsoft Store App Developer Agreement is available here. This update is particularly relevant to developers based in New Zealand or Australia who sell apps and/or in-app products. For more info, view the change history. The next time you log in to the Dev Center dashboard, you may be prompted to accept the new agreement, depending on your account location. 
We’ve also updated the Microsoft Store Policies, which you can view here. The updated policies clarify the requirements for storing or transmitting personal information, and add a new requirement stating that apps using app-specific authentication can only be published from company accounts. For more info, view the change history.   
If you have feedback on the policies, please let us know by commenting in the Microsoft Store forum. 

Windows Community Standup on February 22, 2018

Kevin Gallo, VP of Windows Developer Platform, is hosting the next Windows Community Standup on February 22, 2018 at 12:00pm PST on Channel 9! 
Kevin will be joined by Andrew Whitechapel to discuss the latest updates to the application model which will be available in the next update for Windows 10. Andrew and Kevin will discuss multi-instance, broader file access, and UWP console applications. We will also be answering your questions live.  
Windows community standup is a monthly online broadcast where we provide additional transparency on what we are building and why we are excited. As always, we welcome your feedback. 
Once again, please tune in on February 22, 2018 at 12:00pm PST on https://channel9.msdn.com.

#ifdef WINDOWS – One Developer’s Guide to the Surface Hub

Building experiences for the Surface Hub requires developers to tailor their apps for the big screen and multiple users interacting with different components at the same time. Gian Paolo Santopaolo came to Redmond all the way from Switzerland to share best practices for developing engaging and natural user experiences for the Surface Hub. He has spent the last 6 years as a Windows MVP, designing and developing natural user experiences for various devices including the Microsoft Surface Hub and Microsoft HoloLens. During this time, Gian Paolo has developed many open source components and helpers to enable developers to build better and more personal UWP apps for every device and scenario.
Watch the full video above and feel free to reach out on Twitter or in the comments below for questions or comments.
Happy coding!

This Week on Windows: Amazon Music app, fifth anniversary of Surface Pro and more

We hope you enjoyed this week’s episode of This Week on Windows! Visit this post to read about the Amazon Music app for Windows 10, now available from Microsoft Store, check out our Windows 10 Tip on 7 pro tips for getting started with Microsoft Edge as your PDF viewer or head over here for the system requirements for Sea of Thieves on Windows 10!
In case you missed it:

 

Have a great weekend!

Visual Studio Preview (15.6 Preview 5) now available

We are pleased to announce the release of the Visual Studio Preview (15.6 Preview 5). This preview of Visual Studio includes the Preview SDK Build 17095 as an optional component.
Download the Visual Studio 2017 Preview (https://www.visualstudio.com/vs/preview/) and give us feedback on the integration and setup experience.
For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.
For Visual Studio specific release notes, see release notes.
Known Issues
Cannot deploy to a device: When attempting to deploy to a mobile device, it fails with the following error: DEP0001: Unexpected Error: SmartDeviceException – Class not registered [0x80131500]
To work around this issue:
Go to Administrative Command Prompt
Run REGSVR32 “Program Files (x86)Windows Kits10bin10.0.17095.0x86SirepClient.dll”
The following tools are not included with this release: 
Filtdump.exe
JSConstraintDebug.exe
Regwindmd.exe
Topedit.exe
What’s New:
C++/WinRT Now Available:The C++/WinRT headers and cppwinrt compiler (cppwinrt.exe) are now included in the Windows SDK. The compiler comes in handy if you need to consume a third-party WinRT component or if you need to author your own WinRT components with C++/WinRT. The easiest way to get working with it after installing the Windows Insider Preview SDK is to start the Visual Studio Developer Command Prompt and run the compiler in that environment. Authoring support is currently experimental and subject to change. Stay tuned as we will publish more detailed instructions on how to use the compiler in the coming week.The ModernCPP blog has a deeper dive into the CppWinRT compiler. Please give us feedback by creating an issue at: https://github.com/microsoft/cppwinrt.
Accessing New APIs
In order to access the new APIs, you will need to modify the Target Platform Version of your app to be 10.0.17095.0. By default, the Target Platform Version will target the Windows Fall Creators Update version.
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.
For a list of the New APIs available with this release, see the Windows 10 SDK Preview blog post.

Announcing Windows 10 Insider Preview Build 17101 for Fast & Build 17604 for Skip Ahead

Hello Windows Insiders!
Today, we are releasing Windows 10 Insider Preview Build 17101 (RS4) to Windows Insiders in the Fast ring. We are also releasing Windows 10 Insider Preview Build 17604 (RS5) to Windows Insiders who have opted into Skip Ahead.
Flighting to Skip Ahead
Right now our focus is on stabilization for RS4. As part of the stabilization process, we have “forked” RS4 into its own branch called “RS4_RELEASE” just like we did with RS2 and RS3. Going forward – RS4 builds will come from the RS4_RELEASE branch. This also means that we intend to release new RS4 builds to Insiders more quickly to both the Fast and Slow rings as these builds we include mostly bug fixes.
In RS3, we experimented with the idea of flighting two different releases at the same time with something we called Skip Ahead. A subset of Insiders were able to choose to “skip ahead” to the next release of Windows 10 and receive builds from RS4 while we were finishing up RS3. That experiment went well as our engineering teams benefited from the early feedback. So we’re going to do it again!

Up until today – Insiders who opted into Skip Ahead previously were receiving the same exact RS4 builds as Insiders in the Fast ring since Build 17017. Skip Ahead never “turned off” and many Insiders remained in Skip Ahead since joining at the beginning of RS4. Starting today – Windows Insiders who opted into Skip Ahead will now start receiving new builds for RS5 which is our next Windows 10 release. These builds will come from the RS_PRERELEASE branch.
We are only allowing a small subset of Insiders in the Fast ring to opt in to Skip Ahead as we still need Insiders to hammer on RS4. Because many Insiders who opted in last time remained in Skip Ahead, the limit for Skip Ahead has already been met. This means that if you are not already in Skip Ahead, you will see the Skip Ahead option under Settings > Update & Security > Windows Insider Program greyed out. If we open Skip Ahead up for more Insiders, we’ll let you know. However once we’ve finished RS4, we will move everyone in the Fast ring back to the RS_PRERELEASE branch and then the Fast ring and Skip Ahead will be back to receiving the same builds again.
Please be aware that builds from RS_PRERELEASE will get less stable as teams start checking in new code. So, things will likely be a little rough as they normally are at the beginning of the development cycle for a new Windows 10 release. If this concerns you or makes you uncomfortable, you may want to consider opting out of Skip Ahead and simply wait for the Fast ring to transition back to RS_PRERELEASE down the road.
What’s new in Build 17101 & Build 17604
Input Improvements
Emoji design updates: Based on your feedback and to improve consistency, we’ve made adjustments to the design of some of our emoji. Examples of updated emoji include:
Before:
After:

Emoji search comes to more languages: Earlier in RS4, we updated the Emoji Panel to support browsing and picking emoji in many new locales. With today’s build, we’re bringing search support to more locales too! Now you can find an emoji by keyword in over 150 locales, including English (Great Britain), French (France), German (Germany), Spanish (Spain), and more. This will help you get the emoji you want easily and quickly. As a reminder, to bring up the Emoji Panel set focus to a text field and press WIN + (period) or WIN + (semicolon).

Windows App Permissions
UWP File System Access: With this build we’re giving you more control so you can now decide which UWP apps can access your full file system. Particular UWP apps will be granted permission to have broad file system access. This capability will be granted on a per app basis by Microsoft. If a UWP app has the broad file system access restricted capability, you will receive a consent dialog prompting you to accept or deny the request. If at any time you change your mind about the decision, you can go to Settings > Privacy where you’ll find a new Settings page for File System Access. On this page, you can turn access on or off globally, and if it’s on you can also turn it on or off for each app that has requested the capability. UWPs with broad file system access will not appear in the Photos, Videos, or Documents privacy settings pages. If you grant broad file system access, this includes Photos, Videos and Documents.
New features for Windows 10 Pro for Workstations
Last year, as part of the Windows 10 Fall Creator’s update, we announced a new edition of Windows designed for demanding mission critical scenarios targeting advanced users. As part of RS4, we are adding two more features for our most advanced users running these mission critical scenarios:
A new power scheme – Ultimate Performance: Demanding workloads on workstations always desire more performance. As part of our effort to provide the absolute maximum performance we’re introducing a new power policy called Ultimate Performance. Windows has developed key areas where performance and efficiency tradeoffs are made in the OS. Over time, we’ve amassed a collection of settings which allow the OS to quickly tune the behavior based on user preference, policy, underlying hardware or workload.
This new policy builds on the current High-Performance policy, and it goes a step further to eliminate micro-latencies associated with fine grained power management techniques. The Ultimate Performance Power plan is selectable either by an OEM on new systems or selectable by a user. To do so, you can go to Control Panel and navigate to Power Options under Hardware and Sound (you can also “run” Powercfg.cpl). Just like other power policies in Windows, the contents of the Ultimate Performance policy can be customized.

As the power scheme is geared towards reducing micro-latencies it may directly impact hardware; and consume more power than the default balanced plan. The Ultimate Performance power policy is currently not available on battery powered systems.
We’ll continue to tune and evaluate the power plan settings. To submit feedback please use the Feedback Hub and file your feedback under Power & Battery > Setting category.
Productivity focused out of box applications: In the Windows 10 Fall Creators Update, the out of box experience for Windows 10 Pro for Workstations draws from the Pro edition of Windows 10. One area where this is noticeable is the suite of applications installed out of the box visible as tiles in the start menu. In the next release for Windows, you will see for Windows 10 Pro for Workstations productivity and enterprise focused applications in place of consumer applications and games. This was one of the top feedback shared with us by our partners and users and we’re delivering this in our next update.

If you’re a Windows Insider running the Workstation or Enterprise edition, you can see these features in Builds 17079 or greater.
General changes, improvements, and fixes for PC (Build 17101)
We fixed an issue from the last flight were some PCs failed to resume from hibernate (requiring a hard reboot to recover).
We fixed an issue resulting in 3 and 4 finger gestures on the touchpad being unresponsive in the last two flights.
We fixed an issue after upgrading to the last flight where Start didn’t work for Insiders who’d had HomeGroup added as a folder to appear on Start.
We’ve updated the touch keyboard so that if you try to shapewrite in an unsupported text field or when the typing resources aren’t installed, you won’t see the shapewriting trail as you swipe your finger over the keys.
We fixed an issue where the touch keyboard showed an English layout with no IME on/off key when an East Asian keyboard is the only input method on your system.
We fixed an issue where if you install a font product from the Microsoft Store, then later install a new build (feature update), the Store package will remain installed, but the fonts within the package are not installed. Until this is fixed, the temporary workaround is to uninstall the product from the Apps page in Settings, then re-acquire the product from the Store.
We fixed an issue where the touch keyboard might stop invoking automatically after locking the PC and then unlocking the PC by using the touch keyboard to enter your PIN or password.
We fixed an issue where the Japanese IME sometimes wouldn’t turn on correctly.
We fixed an issue where the floating dictation UI could be unexpectedly tiny.
We fixed an issue that could result in the mouse cursor suddenly jump to screen corner while mouse was moving in a List Control.
We fixed an issue that could result in tabs hanging and not loading content recently in Microsoft Edge after using the browser for a few days with an adblocker enabled.
We fixed an issue resulting in newly installed Microsoft Edge extensions not appearing in the Extensions pane in the last two flights.
We fixed an issue in Microsoft Edge where favicons in light theme were unexpectedly getting black backgrounds.
We fixed an issue that could result in UWP apps sometimes launching as small white rectangular boxes.
We fixed an issue resulting in certain fingerprint readers not working in recent flights.
We fixed an issue where Windows Hello failed to work on Surface Laptops with the last build.
We fixed an issue that could result in the labels for files on the desktop overlapping their icons.
We’re updating the “Advanced graphics settings” link on the Display Settings page to now just say “Graphics Settings”.
When your volume is muted, the volume icons in the Sound Settings page will also now appear muted.
If you click the Reset button on the App volume and device preferences page, it will now also reset any app specific volumes you’ve set back to default (100%).
We fixed an issue resulting in app updates failing in the Microsoft Store with error 0x80070057 in recent builds.
We fixed an issue resulting in app updates failing in the Microsoft Store with error 0x803FB005 in recent builds.
We fixed an issue where bringing up Game bar using the Xbox button on an Xbox One controller didn’t work in some games.
We fixed an issue where in the text box for the Mixer stream title using non-character keys (e.g. Tab, Delete, Backspace, etc.) might cause the game to hang for a few seconds.
We fixed an issue where keyboard and mouse input might not work correctly in the Game bar when playing a first person game (e.g. Minecraft).
We fixed an issue where in some games—such as Destiny 2 and Fortnite—mouse and keyboard input would still go to the game while Game bar was open.
We fixed an issue during first shutdown/boot, or reboot, where for some users the device goes into a boot loop and the OS never loads.
Known issues (Build 17101)
We have observed seeing longer-than-normal delays during install at the 88% mark. Some delays are as long as 90 minutes before moving forward. Please be patient as the install will complete successfully.
Plugging in an external optical drive (DVD) will cause an Explorer.exe crash.
Settings will crash if you open the Themes Settings page.
Buttons on Game bar are not centered correctly.
Selecting a notification after taking a screenshot or game clip opens the Xbox app’s home screen instead of opening the screenshot or game clip.
General changes, improvements, and fixes for PC (Build 17604)
We fixed an issue from the last flight were some PCs failed to resume from hibernate (requiring a hard reboot to recover).
We fixed an issue after upgrading to the last flight where Start didn’t work for Insiders who’d had HomeGroup added as a folder to appear on Start.
We’ve updated the touch keyboard so that if you try to shapewrite in an unsupported text field or when the typing resources aren’t installed, you won’t see the shapewriting trail as you swipe your finger over the keys.
Fixed an issue which may have caused a Microsoft Edge tab to crash after playing video when some extensions are enabled
We fixed an issue resulting in newly installed Microsoft Edge extensions not appearing in the Extensions pane in the last two flights.
We fixed an issue where the touch keyboard showed an English layout with no IME on/off key when an East Asian keyboard is the only input method on your system.
We fixed an issue that could result in the mouse cursor suddenly jump to screen corner while mouse was moving in a List Control.
We fixed an issue resulting in certain fingerprint readers not working in recent flights.
We fixed an issue where Windows Hello failed to work on Surface Laptops with the last build.
We’re updating the “Advanced graphics settings” link on the Display Settings page to now just say “Graphics Settings”.
When your volume is muted, the volume icons in the Sound Settings page will also now appear muted.
If you click the Reset button on the App volume and device preferences page, it will now also reset any app specific volumes you’ve set back to default (100%).
We fixed an issue resulting in app updates failing in the Microsoft Store with error 0x80070057 in recent builds.
Known issues (Build 17604)
3 and 4 finger gestures on the touchpad are unresponsive.
The Japanese IME sometimes can’t turn on in UWP apps. If you encounter this issue switch to a Win32 application (e.g. Notepad), turn the IME on there, then switch back to the UWP app.
Plugging in an external optical drive (DVD) will cause an Explorer.exe crash.
Bringing up Game bar using the Xbox button on an Xbox One controller doesn’t work in some games.
In the text box for Mixer stream title, using non-character keys (e.g. Tab, Delete, Backspace, etc.) may cause the game to hang for a few seconds.
Selecting a notification after taking a screenshot or game clip opens the Xbox app’s home screen instead of opening the screenshot or game clip.
In some games—such as Destiny 2 and Fortnite—mouse and keyboard input will still go to the game while Game bar is open.
Buttons on Game bar are not centered correctly.
Keyboard and mouse input may not work correctly in Game bar when playing a first person game (e.g. Minecraft). Alt + Tab out of and into the game should fix this.
Settings will crash if you open the Themes Settings page.
Introducing the Windows App Preview Program
We’re making it easier to try out the latest app updates with Insider Preview builds with the new Windows App Preview Program. We heard feedback from Windows Insiders that having to opt-in to Skip Ahead to receive the latest app updates wasn’t ideal as it required Insiders to also be on super-early and sometimes unstable builds of the OS. Insiders told us they wanted to be able to try out the latest app updates but be on the latest Insider Preview builds from the Fast, Slow, and Release Preview rings. Now through the Windows App Preview Program, Insiders in any ring can opt-in to preview individual apps.
Insiders can opt-in to previews for the following first-wave of apps:
Feedback Hub
Microsoft Photos
Microsoft Sticky Notes
Microsoft Tips
Paint 3D
Windows Alarms & Clock
Windows Calculator
Windows Camera
Windows Mixed Reality Viewer
Windows Voice Recorder
To opt-in to a preview for an app just go to the Settings or About page of the app and click the “Join preview” button. If the limit has been met for that app preview for the app you will get a notification on clicking the button and as more slots open up you can join the preview. Additionally, if you need to leave an app preview you can do so by also going to the Settings or About page and clicking the “Leave preview” button. These apps are rolling out previews in the next few days, so keep checking the app Settings/About page!

If you are an Insider who has already opted into Skip Ahead – you don’t need opt-in to preview these apps. We will continue to push the latest app updates to you just like before.
Right now, the Windows App Preview Program is available to Windows Insiders. We will be looking at the feedback we receive from Insiders with the goal of evolving the Windows App Preview Program over time.
No downtime for Hustle-As-A-Service,
Dona

Mixed Reality at Microsoft – February update

It’s hard to believe that 2018 is almost two months old! Speaking on behalf of everyone on the mixed reality team at Microsoft, we are excited about the year to come. We have a lot of fun things planned.
Because I love mixed reality so much, I thought February 14th (Valentine’s Day for those who celebrate) would be the perfect day to kick off a new regular update from us. Each month we will share some news on what we are doing, and we will highlight some of the great work coming to market from our customers and partners.
Let’s get going with what we have to share today!
Making it easier to get your hands on HoloLens
We have heard loud and clear that people are looking for additional ways to get HoloLens. To support that demand we have two important program updates to share.
HoloLens expands to more markets
First, I’m happy to announce we will soon be making HoloLens available in Singapore and the United Arab Emirates. To all the developers, creators, partners, and customers we will now work with – welcome! With these new additions, HoloLens is now available in 41 markets around the world.
HoloLens now available for rent
Second, many of our customers have expressed a desire to rent HoloLens, so that companies can evaluate before purchasing or increase their inventory temporarily to support tradeshows and events.
Today, we are excited to help remove this barrier and announce that customers in North America can now rent a HoloLens from our partners at ABCOMRENTS. We are also working to bring this program to additional markets in the months ahead. We look forward to sharing those details soon.
For those in the USA and Canada who are interested in renting HoloLens devices, please visit this link.
Continued adoption of mixed reality
The best part of my job is seeing what people around the world are doing with mixed reality. The innovation and development we see on the platform inspires us to create the software and tools needed to bring the potential of mixed reality to life.
Over the first six weeks of 2018, we have seen some really great work from our partners and customers. Here are a few of my favorites.
Trimble expands their mixed reality product portfolio

Last month, Trimble announced Trimble Connect for HoloLens and a new hard hat solution for HoloLens that improves the utility of mixed reality for practical field applications. Trimble has paid close attention to how to support HoloLens as a high-value tool for firstline workers and are continuing to increase their impact on the market.
Trimble Connect for HoloLens is a mixed-reality solution that improves coordination by combining models from multiple stakeholders such as structural, mechanical and electrical trade partners. The solution provides for precise alignment of holographic data on a 1:1 scale on the job site, to review models in the context of the physical environment. Trimble Connect for HoloLens is available now through the Microsoft Store.
Trimble’s Hard Hat Solution for Microsoft HoloLens extends the benefits of HoloLens mixed reality into areas where increased safety requirements are mandated, such as construction sites, offshore facilities, and mining projects. The solution, which is ANSI-approved, integrates the HoloLens holographic computer with an industry-standard hard hat. Trimble’s Hard Hat Solution for HoloLens is expected to be available in the first quarter of 2018.
HP unveils Windows Mixed Reality Headset – Professional Edition
Last week, we saw HP announce the HP Windows Mixed Reality Headset – Professional Edition. What we love about this headset is the work HP is doing to enhance the way work is done within a set of industries we also care deeply about – Engineering Product Dev and design reviews, AEC (Architecture, Engineering & Construction) reviews, and MRO (Maintenance, Repair and Overhaul) training use environments.

Just like the consumer edition, this headset delivers 1440×1440 resolution per eye and up to a 90Hz refresh rate. For businesses, this headset is the perfect combination of comfort and convenience as it comes with easy to clean, replaceable face cushions. It also uses a double-padded headband, easy adjustment knob and front-hinged display for a superb experience for one or more users.
Honeywell introduces mixed reality simulator to train industrial workforce and help close skills gap

Earlier this week Honeywell Process Solutions announced a cloud-based simulation tool named Honeywell Connected Plant Skills Insight Immersive Competency. This new offering uses mixed reality to train plant personnel on critical work activities. With as much as 50 percent of industrial plant personnel due to retire within the next five years, Immersive Competency is designed to bring new industrial workers up–to–speed quickly by enhancing training and delivering it in new and contemporary ways. By implementing experiences that take advantage of both HoloLens and Windows Mixed Reality immersive headsets, Honeywell has been able to deploy a solution that directly links industrial staff competency to plant performance by measuring the training’s effectiveness based on real outcomes.
We look forward to sharing more next month. If you have any questions or needs, feel free to reach out to me on Twitter – @lorrainebardeen.
And – if you celebrate – enjoy Valentine’s Day! Here’s a little something for you.

Lorraine

Mixed Reality at Microsoft – February update
Tweet This

Windows 10 SDK Preview Build 17095 now available

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview. The Preview SDK Build 17095 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 developer feature requests, head over to our Windows Platform UserVoice.
Things to note:
This build is also available in the latest Visual Studio 2017 Preview (https://www.visualstudio.com/vs/preview/)
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.
This build of the Windows SDK will install on Windows 10 Insider Preview and supported Windows operating systems.
Known Issues
Cannot deploy to a device: When attempting to deploy to a mobile device, it fails with the following error: DEP0001: Unexpected Error: SmartDeviceException – Class not registered [0x80131500]
To work around this issue:
Go to Administrative Command Prompt
Run REGSVR32 “Program Files (x86)Windows Kits10bin10.0.17095.0x86SirepClient.dll”
The following tools are not included with this release: 
Filtdump.exe
JSConstraintDebug.exe
Regwindmd.exe
Topedit.exe
What’s New:
C++/WinRT Now Available:The C++/WinRT headers and cppwinrt compiler (cppwinrt.exe) are now included in the Windows SDK. The compiler comes in handy if you need to consume a third-party WinRT component or if you need to author your own WinRT components with C++/WinRT. The easiest way to get working with it after installing the Windows Insider Preview SDK is to start the Visual Studio Developer Command Prompt and run the compiler in that environment. Authoring support is currently experimental and subject to change. Stay tuned as we will publish more detailed instructions on how to use the compiler in the coming week.The ModernCPP blog has a deeper dive into the CppWinRT compiler. Please give us feedback by creating an issue at: https://github.com/microsoft/cppwinrt.
Breaking Changes
New MIDL key words.  
As a part of the “modernizing IDL” effort, several new keywords are added to the midlrt tool. These new keywords will cause build breaks if they are encountered in IDL files.
The new keywords are:
event
set
get
partial
unsealed
overridable
protected
importwinmd
If any of these keywords is used as an identifier, it will generate a build failure indicating a syntax error.
The error will be similar to:
1 >d:ossrconecorecomcombaseunittestastatestserverstestserver6idlremreleasetest.idl(12) : error MIDL2025 : [msg]syntax error [context]: expecting a declarator or * near “)”
To fix this, modify the identifier in error to an “@” prefix in front of the identifier. That will cause MIDL to treat the offending element as an identifier instead of a keyword.
API Updates and Additions
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.
The following APIs have been added to the platform since the release of 16299.

namespace Windows.ApplicationModel {
public enum AddResourcePackageOptions : uint
public sealed class AppInstance
public sealed class PackageCatalog {
IAsyncOperationWithProgress<PackageCatalogAddResourcePackageResult, PackageInstallProgress> AddResourcePackageAsync(string resourcePackageFamilyName, string resourceID, AddResourcePackageOptions options);
IAsyncOperation<PackageCatalogRemoveResourcePackagesResult> RemoveResourcePackagesAsync(IIterable<Package> resourcePackages);
}
public sealed class PackageCatalogAddResourcePackageResult
public sealed class PackageCatalogRemoveResourcePackagesResult
public struct PackageInstallProgress
public enum StartupTaskState {
EnabledByPolicy = 4,
}
}
namespace Windows.ApplicationModel.Activation {
public enum ActivationKind {
BarcodeScannerProvider = 1022,
}
public sealed class BarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IBarcodeScannerPreviewActivatedEventArgs
public interface IBarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs
}
namespace Windows.ApplicationModel.Background {
public enum BackgroundAccessRequestKind
public static class BackgroundExecutionManager {
public static IAsyncOperation<bool> RequestAccessKindAsync(BackgroundAccessRequestKind requestedAccess, string reason);
}
public sealed class CustomSystemEventTrigger : IBackgroundTrigger
public enum CustomSystemEventTriggerRecurrence
public sealed class MobileBroadbandPcoDataChangeTrigger : IBackgroundTrigger
public sealed class NetworkOperatorDataUsageTrigger : IBackgroundTrigger
public sealed class StorageLibraryChangeTrackerTrigger : IBackgroundTrigger
public sealed class TetheringEntitlementCheckTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Calls {
public enum PhoneCallMedia {
AudioAndRealTimeText = 2,
}
public sealed class VoipCallCoordinator {
VoipPhoneCall RequestNewAppInitiatedCall(string context, string contactName, string contactNumber, string serviceName, VoipPhoneCallMedia media);
VoipPhoneCall RequestNewIncomingCall(string context, string contactName, string contactNumber, Uri contactImage, string serviceName, Uri brandingImage, string callDetails, Uri ringtone, VoipPhoneCallMedia media, TimeSpan ringTimeout, string contactRemoteId);
}
public sealed class VoipPhoneCall {
void NotifyCallAccepted(VoipPhoneCallMedia media);
}
}
namespace Windows.ApplicationModel.Core {
public sealed class AppListEntry {
IAsyncOperation<bool> LaunchForUserAsync(User user);
}
}
namespace Windows.ApplicationModel.DataTransfer {
public sealed class DataPackagePropertySet : IIterable<IKeyValuePair<string, object>>, IMap<string, object> {
string ContentSourceUserActivityJson { get; set; }
}
public sealed class DataPackagePropertySetView : IIterable<IKeyValuePair<string, object>>, IMapView<string, object> {
string ContentSourceUserActivityJson { get; }
}
public static class StandardDataFormats {
public static string UserActivityJsonArray { get; }
}
}
namespace Windows.ApplicationModel.Store.Preview {
public enum StoreSystemFeature {
ArchitectureArm64 = 34,
}
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
public sealed class AppInstallItem {
bool LaunchAfterInstall { get; set; }
}
public sealed class AppInstallManager {
IAsyncOperation<bool> GetIsPackageIdentityAllowedToInstallAsync(string correlationVector, string packageIdentityName, string publisherCertificateName);
IAsyncOperation<bool> GetIsPackageIdentityAllowedToInstallForUserAsync(User user, string correlationVector, string packageIdentityName, string publisherCertificateName);
IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesAsync(string correlationVector, string clientId, AppUpdateOptions updateOptions);
IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesForUserAsync(User user, string correlationVector, string clientId, AppUpdateOptions updateOptions);
IAsyncOperation<AppInstallItem> SearchForUpdatesAsync(string productId, string skuId, string correlationVector, string clientId, AppUpdateOptions updateOptions);
IAsyncOperation<AppInstallItem> SearchForUpdatesForUserAsync(User user, string productId, string skuId, string correlationVector, string clientId, AppUpdateOptions updateOptions);
IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallAsync(string productId, string flightId, string clientId, string correlationVector, AppInstallOptions installOptions);
IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallForUserAsync(User user, string productId, string flightId, string clientId, string correlationVector, AppInstallOptions installOptions);
}
public sealed class AppInstallOptions
public sealed class AppInstallStatus {
bool IsStaged { get; }
}
public sealed class AppUpdateOptions
}
namespace Windows.ApplicationModel.UserActivities {
public sealed class UserActivity {
public UserActivity(string activityId);
string ToJson();
public static string ToJsonArray(IIterable<UserActivity> activities);
public static UserActivity TryParseFromJson(string json);
public static IVector<UserActivity> TryParseFromJsonArray(string json);
}
public sealed class UserActivityChannel {
public static void DisableAutoSessionCreation();
IAsyncOperation<IVector<UserActivitySessionHistoryItem>> GetRecentUserActivitiesAsync(int maxUniqueActivities);
IAsyncOperation<IVector<UserActivitySessionHistoryItem>> GetSessionHistoryItemsForUserActivityAsync(string activityId, DateTime startTime);
public static UserActivityChannel TryGetForWebAccount(WebAccount account);
}
public sealed class UserActivityRequest
public sealed class UserActivityRequestedEventArgs
public sealed class UserActivityRequestManager
public sealed class UserActivitySessionHistoryItem
public sealed class UserActivityVisualElements {
string AttributionDisplayText { get; set; }
}
}
namespace Windows.Devices.Bluetooth {
public sealed class BluetoothAdapter {
bool AreClassicSecureConnectionsSupported { get; }
bool AreLowEnergySecureConnectionsSupported { get; }
}
public sealed class BluetoothDevice : IClosable {
bool WasSecureConnectionUsedForPairing { get; }
}
public sealed class BluetoothLEDevice : IClosable {
bool WasSecureConnectionUsedForPairing { get; }
}
}
namespace Windows.Devices.Display {
public sealed class DisplayMonitor
public enum DisplayMonitorConnectionKind
public enum DisplayMonitorDescriptorKind
public enum DisplayMonitorPhysicalConnectorKind
public enum DisplayMonitorUsageKind
}
namespace Windows.Devices.Input.Preview {
public enum GazeDeviceConfigurationStatePreview
public sealed class GazeDevicePreview
public sealed class GazeDeviceWatcherAddedPreviewEventArgs
public sealed class GazeDeviceWatcherPreview
public sealed class GazeDeviceWatcherRemovedPreviewEventArgs
public sealed class GazeDeviceWatcherUpdatedPreviewEventArgs
public sealed class GazeEnteredPreviewEventArgs
public sealed class GazeExitedPreviewEventArgs
public sealed class GazeInputSourcePreview
public sealed class GazeMovedPreviewEventArgs
public sealed class GazePointPreview
}
namespace Windows.Devices.PointOfService {
public sealed class BarcodeScannerReport {
public BarcodeScannerReport(uint scanDataType, IBuffer scanData, IBuffer scanDataLabel);
}
public sealed class ClaimedBarcodeScanner : IClosable {
bool IsVideoPreviewShownOnEnable { get; set; }
void HideVideoPreview();
IAsyncOperation<bool> ShowVideoPreviewAsync();
}
public sealed class UnifiedPosErrorData {
public UnifiedPosErrorData(string message, UnifiedPosErrorSeverity severity, UnifiedPosErrorReason reason, uint extendedReason);
}
}
namespace Windows.Devices.PointOfService.Provider {
public sealed class BarcodeScannerDisableScannerRequest
public sealed class BarcodeScannerDisableScannerRequestEventArgs
public sealed class BarcodeScannerEnableScannerRequest
public sealed class BarcodeScannerEnableScannerRequestEventArgs
public sealed class BarcodeScannerGetSymbologyAttributesRequest
public sealed class BarcodeScannerGetSymbologyAttributesRequestEventArgs
public sealed class BarcodeScannerHideVideoPreviewRequest
public sealed class BarcodeScannerHideVideoPreviewRequestEventArgs
public sealed class BarcodeScannerProviderConnection : IClosable
public sealed class BarcodeScannerProviderTriggerDetails
public sealed class BarcodeScannerSetActiveSymbologiesRequest
public sealed class BarcodeScannerSetActiveSymbologiesRequestEventArgs
public sealed class BarcodeScannerSetSymbologyAttributesRequest
public sealed class BarcodeScannerSetSymbologyAttributesRequestEventArgs
public sealed class BarcodeScannerStartSoftwareTriggerRequest
public sealed class BarcodeScannerStartSoftwareTriggerRequestEventArgs
public sealed class BarcodeScannerStopSoftwareTriggerRequest
public sealed class BarcodeScannerStopSoftwareTriggerRequestEventArgs
public enum BarcodeScannerTriggerState
public sealed class BarcodeSymbologyAttributesBuilder
}
namespace Windows.Foundation.Numerics {
public struct Rational
}
namespace Windows.Globalization {
public static class ApplicationLanguages {
public static IVectorView<string> GetLanguagesForUser(User user);
}
public sealed class Language {
LanguageLayoutDirection LayoutDirection { get; }
}
public enum LanguageLayoutDirection
}
namespace Windows.Graphics {
public struct DisplayAdapterId
public interface IGeometrySource2D
}
namespace Windows.Graphics.Capture {
public sealed class Direct3D11CaptureFrame : IClosable
public sealed class Direct3D11CaptureFramePool : IClosable
public sealed class GraphicsCaptureItem
public sealed class GraphicsCapturePicker
public sealed class GraphicsCaptureSession : IClosable
}
namespace Windows.Graphics.DirectX {
public enum DirectXColorSpace
}
namespace Windows.Graphics.Display {
public sealed class AdvancedColorInfo
public enum AdvancedColorKind
public sealed class BrightnessOverrideSettings
public sealed class ColorOverrideSettings
public enum DisplayBrightnessOverrideScenario
public enum DisplayColorOverrideScenario
public sealed class DisplayEnhancementOverride
public sealed class DisplayEnhancementOverrideCapabilities
public sealed class DisplayEnhancementOverrideCapabilitiesChangedEventArgs
public sealed class DisplayInformation {
event TypedEventHandler<DisplayInformation, object> AdvancedColorInfoChanged;
AdvancedColorInfo GetAdvancedColorInfo();
}
public enum HdrMetadataFormat
public struct NitRange
}
namespace Windows.Graphics.Holographic {
public sealed class HolographicCamera {
bool CanOverrideViewport { get; }
}
public sealed class HolographicCameraPose {
void OverrideProjectionTransform(HolographicStereoTransform projectionTransform);
void OverrideViewport(Rect leftViewport, Rect rightViewport);
void OverrideViewTransform(SpatialCoordinateSystem coordinateSystem, HolographicStereoTransform coordinateSystemToViewTransform);
}
public sealed class HolographicFramePresentationMonitor : IClosable
public sealed class HolographicFramePresentationReport
public sealed class HolographicSpace {
HolographicSpaceUserPresence UserPresence { get; }
event TypedEventHandler<HolographicSpace, object> UserPresenceChanged;
HolographicFramePresentationMonitor CreateFramePresentationMonitor(uint maxQueuedReports);
void WaitForNextFrameReady();
void WaitForNextFrameReadyWithHeadStart(TimeSpan requestedHeadStartDuration);
}
public enum HolographicSpaceUserPresence
}
namespace Windows.Graphics.Imaging {
public enum BitmapPixelFormat {
P010 = 104,
}
}
namespace Windows.Graphics.Printing {
public sealed class PrintPageRange
public sealed class PrintPageRangeOptions
public sealed class PrintTaskOptions : IPrintTaskOptionsCore, IPrintTaskOptionsCoreProperties, IPrintTaskOptionsCoreUIConfiguration {
IVector<PrintPageRange> CustomPageRanges { get; }
PrintPageRangeOptions PageRangeOptions { get; }
}
public static class StandardPrintTaskOptions {
public static string CustomPageRanges { get; }
}
}
namespace Windows.Graphics.Printing.OptionDetails {
public sealed class PrintBindingOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public sealed class PrintBorderingOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public sealed class PrintCollationOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public sealed class PrintColorModeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public sealed class PrintCopiesOptionDetails : IPrintNumberOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public sealed class PrintCustomItemListOptionDetails : IPrintCustomOptionDetails, IPrintItemListOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
void AddItem(string itemId, string displayName, string description, IRandomAccessStreamWithContentType icon);
}
public sealed class PrintCustomTextOptionDetails : IPrintCustomOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public sealed class PrintCustomToggleOptionDetails : IPrintCustomOptionDetails, IPrintOptionDetails
public sealed class PrintDuplexOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public sealed class PrintHolePunchOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public sealed class PrintMediaSizeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public sealed class PrintMediaTypeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public enum PrintOptionType {
Toggle = 4,
}
public sealed class PrintOrientationOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public sealed class PrintPageRangeOptionDetails : IPrintOptionDetails
public sealed class PrintQualityOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public sealed class PrintStapleOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
string Description { get; set; }
string WarningText { get; set; }
}
public sealed class PrintTaskOptionDetails : IPrintTaskOptionsCore, IPrintTaskOptionsCoreUIConfiguration {
PrintCustomToggleOptionDetails CreateToggleOption(string optionId, string displayName);
}
}
namespace Windows.Management.Deployment {
public sealed class PackageManager {
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> relatedPackageUris, IIterable<Uri> packageUrisToInstall);
}
}
namespace Windows.Management.Update {
public sealed class PreviewBuildsManager
public sealed class PreviewBuildsState
}
namespace Windows.Media {
public sealed class VideoFrame : IClosable, IMediaFrame {
IAsyncAction CopyToAsync(VideoFrame frame, IReference<BitmapBounds> sourceBounds, IReference<BitmapBounds> destinationBounds);
public static VideoFrame CreateAsDirect3D11SurfaceBacked(DirectXPixelFormat format, int width, int height);
public static VideoFrame CreateAsDirect3D11SurfaceBacked(DirectXPixelFormat format, int width, int height, IDirect3DDevice device);
public static VideoFrame CreateWithDirect3D11Surface(IDirect3DSurface surface);
public static VideoFrame CreateWithSoftwareBitmap(SoftwareBitmap bitmap);
}
}
namespace Windows.Media.Audio {
public sealed class AudioGraph : IClosable {
IAsyncOperation<CreateMediaSourceAudioInputNodeResult> CreateMediaSourceAudioInputNodeAsync(MediaSource mediaSource);
IAsyncOperation<CreateMediaSourceAudioInputNodeResult> CreateMediaSourceAudioInputNodeAsync(MediaSource mediaSource, AudioNodeEmitter emitter);
}
public sealed class AudioGraphSettings {
double MaxPlaybackSpeedFactor { get; set; }
}
public sealed class AudioStateMonitor
public sealed class CreateMediaSourceAudioInputNodeResult
public sealed class MediaSourceAudioInputNode : IAudioInputNode, IAudioInputNode2, IAudioNode, IClosable
public enum MediaSourceAudioInputNodeCreationStatus
}
namespace Windows.Media.Capture {
public sealed class CapturedFrame : IClosable, IContentTypeProvider, IInputStream, IOutputStream, IRandomAccessStream, IRandomAccessStreamWithContentType {
BitmapPropertySet BitmapProperties { get; }
CapturedFrameControlValues ControlValues { get; }
}
public enum KnownVideoProfile {
HdrWithWcgPhoto = 8,
HdrWithWcgVideo = 7,
HighFrameRate = 5,
VariablePhotoSequence = 6,
VideoHdr8 = 9,
}
public sealed class MediaCaptureSettings {
IDirect3DDevice Direct3D11Device { get; }
}
public sealed class MediaCaptureVideoProfile {
IVectorView<MediaFrameSourceInfo> FrameSourceInfos { get; }
IMapView<Guid, object> Properties { get; }
}
public sealed class MediaCaptureVideoProfileMediaDescription {
IMapView<Guid, object> Properties { get; }
string Subtype { get; }
}
}
namespace Windows.Media.Capture.Frames {
public sealed class AudioMediaFrame
public sealed class MediaFrameFormat {
AudioEncodingProperties AudioEncodingProperties { get; }
}
public sealed class MediaFrameReference : IClosable {
AudioMediaFrame AudioMediaFrame { get; }
}
public sealed class MediaFrameSourceController {
AudioDeviceController AudioDeviceController { get; }
}
public sealed class MediaFrameSourceInfo {
string ProfileId { get; }
IVectorView<MediaCaptureVideoProfileMediaDescription> VideoProfileMediaDescription { get; }
}
public enum MediaFrameSourceKind {
Audio = 4,
Image = 5,
}
}
namespace Windows.Media.Core {
public sealed class AudioStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
AudioStreamDescriptor Copy();
}
public sealed class MediaBindingEventArgs {
void SetDownloadOperation(DownloadOperation downloadOperation);
}
public sealed class MediaSource : IClosable, IMediaPlaybackSource {
DownloadOperation DownloadOperation { get; }
public static MediaSource CreateFromDownloadOperation(DownloadOperation downloadOperation);
}
public sealed class TimedMetadataStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2
public sealed class VideoStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
VideoStreamDescriptor Copy();
}
}
namespace Windows.Media.Devices {
public sealed class VideoDeviceController : IMediaDeviceController {
VideoTemporalDenoisingControl VideoTemporalDenoisingControl { get; }
}
public sealed class VideoTemporalDenoisingControl
public enum VideoTemporalDenoisingMode
}
namespace Windows.Media.DialProtocol {
public sealed class DialReceiverApp {
IAsyncOperation<string> GetUniqueDeviceNameAsync();
}
}
namespace Windows.Media.Effects {
public sealed class VideoTransformEffectDefinition : IVideoEffectDefinition {
VideoTransformSphericalProjection SphericalProjection { get; }
}
public sealed class VideoTransformSphericalProjection
}
namespace Windows.Media.MediaProperties {
public sealed class AudioEncodingProperties : IMediaEncodingProperties {
AudioEncodingProperties Copy();
}
public sealed class ContainerEncodingProperties : IMediaEncodingProperties {
ContainerEncodingProperties Copy();
}
public sealed class ImageEncodingProperties : IMediaEncodingProperties {
ImageEncodingProperties Copy();
}
public sealed class MediaEncodingProfile {
IVector<TimedMetadataStreamDescriptor> GetTimedMetadataTracks();
void SetTimedMetadataTracks(IIterable<TimedMetadataStreamDescriptor> value);
}
public static class MediaEncodingSubtypes {
public static string P010 { get; }
}
public enum MediaPixelFormat {
P010 = 2,
}
public sealed class TimedMetadataEncodingProperties : IMediaEncodingProperties
public sealed class VideoEncodingProperties : IMediaEncodingProperties {
VideoEncodingProperties Copy();
}
}
namespace Windows.Media.Playback {
public sealed class MediaPlaybackSession {
MediaRotation PlaybackRotation { get; set; }
MediaPlaybackSessionOutputDegradationPolicyState GetOutputDegradationPolicyState();
}
public sealed class MediaPlaybackSessionOutputDegradationPolicyState
public enum MediaPlaybackSessionVideoConstrictionReason
public sealed class MediaPlayer : IClosable {
AudioStateMonitor AudioStateMonitor { get; }
}
}
namespace Windows.Media.SpeechSynthesis {
public enum SpeechAppendedSilence
public enum SpeechPunctuationSilence
public sealed class SpeechSynthesizerOptions {
SpeechAppendedSilence AppendedSilence { get; set; }
SpeechPunctuationSilence PunctuationSilence { get; set; }
}
}
namespace Windows.Media.Streaming.Adaptive {
public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs {
string ResourceContentType { get; }
IReference<TimeSpan> ResourceDuration { get; }
}
public sealed class AdaptiveMediaSourceDownloadCompletedEventArgs {
string ResourceContentType { get; }
IReference<TimeSpan> ResourceDuration { get; }
}
public sealed class AdaptiveMediaSourceDownloadFailedEventArgs {
string ResourceContentType { get; }
IReference<TimeSpan> ResourceDuration { get; }
}
public sealed class AdaptiveMediaSourceDownloadRequestedEventArgs {
string ResourceContentType { get; }
IReference<TimeSpan> ResourceDuration { get; }
}
}
namespace Windows.Networking.BackgroundTransfer {
public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
void MakeCurrentInTransferGroup();
}
public sealed class UploadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
void MakeCurrentInTransferGroup();
}
}
namespace Windows.Networking.Connectivity {
public sealed class CellularApnContext {
string ProfileName { get; set; }
}
public sealed class ConnectionProfileFilter {
IReference<Guid> PurposeGuid { get; set; }
}
public sealed class WwanConnectionProfileDetails {
WwanNetworkIPKind IPKind { get; }
IVectorView<Guid> PurposeGuids { get; }
}
public enum WwanNetworkIPKind
}
namespace Windows.Networking.NetworkOperators {
public sealed class ESim
public sealed class ESimAddedEventArgs
public enum ESimAuthenticationPreference
public sealed class ESimDownloadProfileMetadataResult
public static class ESimManager
public sealed class ESimOperationResult
public enum ESimOperationStatus
public sealed class ESimPolicy
public sealed class ESimProfile
public enum ESimProfileClass
public struct ESimProfileInstallProgress
public sealed class ESimProfileMetadata
public enum ESimProfileMetadataState
public sealed class ESimProfilePolicy
public enum ESimProfileState
public sealed class ESimRemovedEventArgs
public sealed class ESimServiceInfo
public enum ESimState
public sealed class ESimUpdatedEventArgs
public sealed class ESimWatcher
public enum ESimWatcherStatus
public sealed class MobileBroadbandAntennaSar {
public MobileBroadbandAntennaSar(int antennaIndex, int sarBackoffIndex);
}
public sealed class MobileBroadbandModem {
bool IsInEmergencyCallMode { get; }
event TypedEventHandler<MobileBroadbandModem, object> IsInEmergencyCallModeChanged;
IAsyncOperation<MobileBroadbandPco> TryGetPcoAsync();
}
public sealed class MobileBroadbandModemIsolation
public sealed class MobileBroadbandPco
public sealed class MobileBroadbandPcoDataChangeTriggerDetails
public enum NetworkOperatorDataUsageNotificationKind
public sealed class NetworkOperatorDataUsageTriggerDetails
public sealed class TetheringEntitlementCheckTriggerDetails
}
namespace Windows.Networking.Sockets {
public sealed class MessageWebSocket : IClosable, IWebSocket {
IAsyncOperationWithProgress<uint, uint> SendFinalFrameAsync(IBuffer data);
IAsyncOperationWithProgress<uint, uint> SendNonfinalFrameAsync(IBuffer data);
}
public sealed class ServerMessageWebSocket : IClosable
public sealed class ServerMessageWebSocketControl
public sealed class ServerMessageWebSocketInformation
public sealed class ServerStreamWebSocket : IClosable
public sealed class ServerStreamWebSocketInformation
}
namespace Windows.Networking.Vpn {
public sealed class VpnChannel {
object CurrentRequestTransportContext { get; }
void AddAndAssociateTransport(object transport, object context);
ControlChannelTriggerStatus GetSlotTypeForTransportContext(object context);
void ReplaceAndAssociateTransport(object transport, object context);
void StartReconnectingTransport(object transport, object context);
void StartWithTrafficFilter(IIterable<HostName> assignedClientIpv4Addresses, IIterable<HostName> assignedClientIpv6Addresses, VpnInterfaceId vpninterfaceId, VpnRouteAssignment assignedRoutes, VpnDomainNameAssignment assignedNamespace, uint mtuSize, uint maxFrameSize, bool reserved, IIterable<object> transports, VpnTrafficFilterAssignment assignedTrafficFilters);
}
public sealed class VpnPacketBuffer {
object TransportContext { get; set; }
}
}
namespace Windows.Security.Authentication.Identity.Provider {
public enum SecondaryAuthenticationFactorAuthenticationMessage {
CanceledByUser = 22,
CenterHand = 23,
ConnectionRequired = 20,
DeviceUnavailable = 28,
MoveHandCloser = 24,
MoveHandFarther = 25,
PlaceHandAbove = 26,
RecognitionFailed = 27,
TimeLimitExceeded = 21,
}
}
namespace Windows.Security.Authentication.Web.Core {
public sealed class FindAllAccountsResult
public enum FindAllWebAccountsStatus
public static class WebAuthenticationCoreManager {
public static IAsyncOperation<FindAllAccountsResult> FindAllAccountsAsync(WebAccountProvider provider);
public static IAsyncOperation<FindAllAccountsResult> FindAllAccountsAsync(WebAccountProvider provider, string clientId);
public static IAsyncOperation<WebAccountProvider> FindSystemAccountProviderAsync(string webAccountProviderId);
public static IAsyncOperation<WebAccountProvider> FindSystemAccountProviderAsync(string webAccountProviderId, string authority);
public static IAsyncOperation<WebAccountProvider> FindSystemAccountProviderAsync(string webAccountProviderId, string authority, User user);
}
}
namespace Windows.Security.Authentication.Web.Provider {
public sealed class WebProviderTokenRequest {
string ApplicationPackageFamilyName { get; }
string ApplicationProcessName { get; }
IAsyncOperation<bool> CheckApplicationForCapabilityAsync(string capabilityName);
}
}
namespace Windows.Security.Credentials {
public sealed class WebAccountProvider {
bool IsSystemProvider { get; }
}
}
namespace Windows.Services.Maps {
public sealed class MapRouteDrivingOptions {
IReference<DateTime> DepartureTime { get; set; }
}
public sealed class PlaceInfo {
public static PlaceInfo CreateFromAddress(string displayAddress);
public static PlaceInfo CreateFromAddress(string displayAddress, string displayName);
}
}
namespace Windows.Services.Store {
public sealed class StoreCanAcquireLicenseResult
public enum StoreCanLicenseStatus
public sealed class StoreContext {
bool CanSilentlyDownloadStorePackageUpdates { get; }
IAsyncOperation<StoreCanAcquireLicenseResult> CanAcquireStoreLicenseAsync(string productStoreId);
IAsyncOperation<StoreCanAcquireLicenseResult> CanAcquireStoreLicenseForOptionalPackageAsync(Package optionalPackage);
IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> DownloadAndInstallStorePackagesAsync(IIterable<string> storeIds);
IAsyncOperation<IVectorView<StoreQueueItem>> GetAssociatedStoreQueueItemsAsync();
IAsyncOperation<StoreProductQueryResult> GetStoreProductsAsync(IIterable<string> productKinds, IIterable<string> storeIds, StoreProductOptions storeProductOptions);
IAsyncOperation<IVectorView<StoreQueueItem>> GetStoreQueueItemsAsync(IIterable<string> storeIds);
IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> RequestDownloadAndInstallStorePackagesAsync(IIterable<string> storeIds, StorePackageInstallOptions storePackageInstallOptions);
IAsyncOperation<StoreUninstallStorePackageResult> RequestUninstallStorePackageAsync(Package package);
IAsyncOperation<StoreUninstallStorePackageResult> RequestUninstallStorePackageByStoreIdAsync(string storeId);
IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> TrySilentDownloadAndInstallStorePackageUpdatesAsync(IIterable<StorePackageUpdate> storePackageUpdates);
IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> TrySilentDownloadStorePackageUpdatesAsync(IIterable<StorePackageUpdate> storePackageUpdates);
IAsyncOperation<StoreUninstallStorePackageResult> UninstallStorePackageAsync(Package package);
IAsyncOperation<StoreUninstallStorePackageResult> UninstallStorePackageByStoreIdAsync(string storeId);
}
public sealed class StorePackageInstallOptions
public sealed class StorePackageUpdateResult {
IVectorView<StoreQueueItem> StoreQueueItems { get; }
}
public sealed class StoreProductOptions
public sealed class StoreQueueItem
public sealed class StoreQueueItemCompletedEventArgs
public enum StoreQueueItemExtendedState
public enum StoreQueueItemKind
public enum StoreQueueItemState
public sealed class StoreQueueItemStatus
public sealed class StoreUninstallStorePackageResult
public enum StoreUninstallStorePackageStatus
}
namespace Windows.Storage {
public sealed class StorageFolder : IStorageFolder, IStorageFolder2, IStorageFolderQueryOperations, IStorageItem, IStorageItem2, IStorageItemProperties, IStorageItemProperties2, IStorageItemPropertiesWithProvider {
StorageLibraryChangeTracker TryGetChangeTracker();
}
}
namespace Windows.Storage.Provider {
public interface IStorageProviderUriSource
public sealed class StorageProviderGetContentInfoForPathResult
public sealed class StorageProviderGetPathForContentUriResult
public enum StorageProviderUriSourceStatus
}
namespace Windows.Storage.Search {
public sealed class StorageLibraryChangeTrackerTriggerDetails
}
namespace Windows.System {
public sealed class AppActivationResult
public sealed class AppDiagnosticInfo {
IAsyncOperation<AppActivationResult> LaunchAsync();
}
public sealed class AppExecutionStateChangeResult
public sealed class AppResourceGroupInfo {
IAsyncOperation<AppExecutionStateChangeResult> StartResumeAsync();
IAsyncOperation<AppExecutionStateChangeResult> StartSuspendAsync();
IAsyncOperation<AppExecutionStateChangeResult> StartTerminateAsync();
}
public enum AutoUpdateTimeZoneStatus
public static class TimeZoneSettings {
public static IAsyncOperation<AutoUpdateTimeZoneStatus> AutoUpdateTimeZoneAsync(TimeSpan timeout);
}
}
namespace Windows.System.Diagnostics {
public sealed class DiagnosticInvoker {
IAsyncOperationWithProgress<DiagnosticActionResult, DiagnosticActionState> RunDiagnosticActionFromStringAsync(string context);
}
}
namespace Windows.System.Diagnostics.DevicePortal {
public sealed class DevicePortalConnection {
ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request);
ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request, SocketMessageType messageType, string protocol);
ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request, SocketMessageType messageType, string protocol, uint outboundBufferSizeInBytes, uint maxMessageSize, MessageWebSocketReceiveMode receiveMode);
ServerStreamWebSocket GetServerStreamWebSocketForRequest(HttpRequestMessage request);
ServerStreamWebSocket GetServerStreamWebSocketForRequest(HttpRequestMessage request, string protocol, uint outboundBufferSizeInBytes, bool noDelay);
}
public sealed class DevicePortalConnectionRequestReceivedEventArgs {
bool IsWebSocketUpgradeRequest { get; }
IVectorView<string> WebSocketProtocolsRequested { get; }
Deferral GetDeferral();
}
}
namespace Windows.System.Inventory {
public sealed class InstalledDesktopApp : IStringable
}
namespace Windows.System.Profile {
public static class AnalyticsInfo {
public static IAsyncOperation<IMapView<string, string>> GetSystemPropertiesAsync(IIterable<string> attributeNames);
}
}
namespace Windows.System.RemoteSystems {
public sealed class RemoteSystem {
RemoteSystemPlatform Platform { get; }
}
public sealed class RemoteSystemEnumerationCompletedEventArgs
public enum RemoteSystemPlatform
public sealed class RemoteSystemWatcher {
event TypedEventHandler<RemoteSystemWatcher, RemoteSystemEnumerationCompletedEventArgs> EnumerationCompleted;
event TypedEventHandler<RemoteSystemWatcher, RemoteSystemWatcherErrorOccurredEventArgs> ErrorOccurred;
}
public enum RemoteSystemWatcherError
public sealed class RemoteSystemWatcherErrorOccurredEventArgs
}
namespace Windows.System.UserProfile {
public static class GlobalizationPreferences {
public static GlobalizationPreferencesForUser GetForUser(User user);
}
public sealed class GlobalizationPreferencesForUser
}
namespace Windows.UI.ApplicationSettings {
public sealed class AccountsSettingsPane {
public static IAsyncAction ShowAddAccountForUserAsync(User user);
public static IAsyncAction ShowManageAccountsForUserAsync(User user);
}
public sealed class AccountsSettingsPaneCommandsRequestedEventArgs {
User User { get; }
}
}
namespace Windows.UI.Composition {
public sealed class AnimationController : CompositionObject
public enum AnimationControllerProgressBehavior
public sealed class BounceScalarNaturalMotionAnimation : ScalarNaturalMotionAnimation
public sealed class BounceVector2NaturalMotionAnimation : Vector2NaturalMotionAnimation
public sealed class BounceVector3NaturalMotionAnimation : Vector3NaturalMotionAnimation
public sealed class CompositionContainerShape : CompositionShape
public sealed class CompositionEllipseGeometry : CompositionGeometry
public class CompositionGeometry : CompositionObject
public class CompositionLight : CompositionObject {
bool IsEnabled { get; set; }
}
public sealed class CompositionLineGeometry : CompositionGeometry
public class CompositionObject : IClosable {
AnimationController TryGetAnimationController(string propertyName);
}
public sealed class CompositionPath : IGeometrySource2D
public sealed class CompositionPathGeometry : CompositionGeometry
public sealed class CompositionRectangleGeometry : CompositionGeometry
public sealed class CompositionRoundedRectangleGeometry : CompositionGeometry
public class CompositionShape : CompositionObject
public sealed class CompositionShapeCollection : CompositionObject, IIterable<CompositionShape>, IVector<CompositionShape>
public sealed class CompositionSpriteShape : CompositionShape
public enum CompositionStrokeCap
public sealed class CompositionStrokeDashArray : CompositionObject, IIterable<float>, IVector<float>
public enum CompositionStrokeLineJoin
public sealed class CompositionViewBox : CompositionObject
public sealed class Compositor : IClosable {
string Comment { get; set; }
float GlobalPlaybackRate { get; set; }
public static float MaxGlobalPlaybackRate { get; }
public static float MinGlobalPlaybackRate { get; }
BounceScalarNaturalMotionAnimation CreateBounceScalarAnimation();
BounceVector2NaturalMotionAnimation CreateBounceVector2Animation();
BounceVector3NaturalMotionAnimation CreateBounceVector3Animation();
CompositionContainerShape CreateContainerShape();
CompositionEllipseGeometry CreateEllipseGeometry();
CompositionLineGeometry CreateLineGeometry();
CompositionPathGeometry CreatePathGeometry();
CompositionPathGeometry CreatePathGeometry(CompositionPath path);
PathKeyFrameAnimation CreatePathKeyFrameAnimation();
CompositionRectangleGeometry CreateRectangleGeometry();
CompositionRoundedRectangleGeometry CreateRoundedRectangleGeometry();
ShapeVisual CreateShapeVisual();
CompositionSpriteShape CreateSpriteShape();
CompositionSpriteShape CreateSpriteShape(CompositionGeometry geometry);
CompositionViewBox CreateViewBox();
IAsyncAction RequestCommitAsync();
}
public sealed class PathKeyFrameAnimation : KeyFrameAnimation
public sealed class PointLight : CompositionLight {
float MaxAttenuationCutoff { get; set; }
float MinAttenuationCutoff { get; set; }
}
public sealed class ShapeVisual : ContainerVisual
public sealed class SpotLight : CompositionLight {
float MaxAttenuationCutoff { get; set; }
float MinAttenuationCutoff { get; set; }
}
}
namespace Windows.UI.Composition.Core {
public sealed class CompositorController : IClosable
}
namespace Windows.UI.Composition.Desktop {
public sealed class DesktopWindowTarget : CompositionTarget
}
namespace Windows.UI.Composition.Diagnostics {
public sealed class CompositionDebugHeatMaps
public enum CompositionDebugOverdrawContentKinds : uint
public sealed class CompositionDebugSettings
}
namespace Windows.UI.Composition.Interactions {
public enum VisualInteractionSourceRedirectionMode {
CapableTouchpadAndPointerWheel = 3,
PointerWheelOnly = 2,
}
}
namespace Windows.UI.Core {
public enum AppViewBackButtonVisibility {
Disabled = 2,
}
public sealed class CoreComponentInputSource : ICoreInputSourceBase, ICorePointerInputSource, ICorePointerInputSource2 {
DispatcherQueue DispatcherQueue { get; }
}
public sealed class CoreIndependentInputSource : ICoreInputSourceBase, ICorePointerInputSource, ICorePointerInputSource2 {
DispatcherQueue DispatcherQueue { get; }
}
public interface ICorePointerInputSource2 : ICorePointerInputSource
}
namespace Windows.UI.Input.Core {
public sealed class RadialControllerIndependentInputSource {
DispatcherQueue DispatcherQueue { get; }
}
}
namespace Windows.UI.Input.Inking {
public sealed class InkDrawingAttributes {
InkModelerAttributes ModelerAttributes { get; }
}
public sealed class InkInputConfiguration
public sealed class InkModelerAttributes
public sealed class InkPresenter {
InkInputConfiguration InputConfiguration { get; }
}
}
namespace Windows.UI.Input.Spatial {
public sealed class SpatialInteractionController {
BatteryReport TryGetBatteryReport();
}
}
namespace Windows.UI.Notifications {
public sealed class ScheduledToastNotification {
IReference<DateTime> ExpirationTime { get; set; }
}
}
namespace Windows.UI.StartScreen {
public sealed class TileMixedRealityModel {
TileMixedRealityModelActivationBehavior ActivationBehavior { get; set; }
}
public enum TileMixedRealityModelActivationBehavior
}
namespace Windows.UI.Text {
public sealed class ContentLinkInfo
public sealed class RichEditTextRange : ITextRange
public enum TextRangeUnit {
ContentLink = 32,
}
}
namespace Windows.UI.ViewManagement.Core {
public sealed class CoreInputView {
event TypedEventHandler<CoreInputView, object> XYFocusTransferredToPrimaryView;
event TypedEventHandler<CoreInputView, CoreInputViewTransferringXYFocusEventArgs> XYFocusTransferringFromPrimaryView;
bool TryTransferXYFocusToPrimaryView(Rect origin, CoreInputViewXYFocusTransferDirection direction);
}
public sealed class CoreInputViewTransferringXYFocusEventArgs
public enum CoreInputViewXYFocusTransferDirection
}
namespace Windows.UI.WebUI {
public sealed class WebUIBarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IBarcodeScannerPreviewActivatedEventArgs
public sealed class WebUILaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ILaunchActivatedEventArgs, ILaunchActivatedEventArgs2, IPrelaunchActivatedEventArgs {
TileActivatedInfo TileActivatedInfo { get; }
}
}
namespace Windows.UI.Xaml {
public sealed class BringIntoViewOptions {
double HorizontalAlignmentRatio { get; set; }
double HorizontalOffset { get; set; }
double VerticalAlignmentRatio { get; set; }
double VerticalOffset { get; set; }
}
public sealed class BringIntoViewRequestedEventArgs : RoutedEventArgs
public sealed class ElementSoundPlayer {
public static ElementSpatialAudioMode SpatialAudioMode { get; set; }
}
public enum ElementSpatialAudioMode
public enum FocusVisualKind {
Reveal = 2,
}
public class UIElement : DependencyObject {
public static RoutedEvent BringIntoViewRequestedEvent { get; }
public static RoutedEvent ContextRequestedEvent { get; }
KeyboardAcceleratorPlacementMode KeyboardAcceleratorPlacementMode { get; set; }
public static DependencyProperty KeyboardAcceleratorPlacementModeProperty { get; }
DependencyObject KeyboardAcceleratorPlacementTarget { get; set; }
public static DependencyProperty KeyboardAcceleratorPlacementTargetProperty { get; }
DependencyObject KeyTipTarget { get; set; }
public static DependencyProperty KeyTipTargetProperty { get; }
event TypedEventHandler<UIElement, BringIntoViewRequestedEventArgs> BringIntoViewRequested;
virtual void OnBringIntoViewRequested(BringIntoViewRequestedEventArgs e);
virtual void OnKeyboardAcceleratorInvoked(KeyboardAcceleratorInvokedEventArgs args);
public static void RegisterAsScrollPort(UIElement element);
}
}
namespace Windows.UI.Xaml.Automation {
public sealed class AutomationElementIdentifiers {
public static AutomationProperty HeadingLevelProperty { get; }
}
public sealed class AutomationProperties {
public static DependencyProperty HeadingLevelProperty { get; }
public static AutomationHeadingLevel GetHeadingLevel(DependencyObject element);
public static void SetHeadingLevel(DependencyObject element, AutomationHeadingLevel value);
}
}
namespace Windows.UI.Xaml.Automation.Peers {
public enum AutomationHeadingLevel
public class AutomationPeer : DependencyObject {
AutomationHeadingLevel GetHeadingLevel();
virtual AutomationHeadingLevel GetHeadingLevelCore();
}
public sealed class AutoSuggestBoxAutomationPeer : FrameworkElementAutomationPeer, IInvokeProvider {
void Invoke();
}
public class CalendarDatePickerAutomationPeer : FrameworkElementAutomationPeer, IInvokeProvider, IValueProvider
public class TreeViewItemAutomationPeer : ListViewItemAutomationPeer, IExpandCollapseProvider
public class TreeViewListAutomationPeer : SelectorAutomationPeer
}
namespace Windows.UI.Xaml.Controls {
public class AppBarButton : Button, ICommandBarElement, ICommandBarElement2 {
string KeyboardAcceleratorTextOverride { get; set; }
public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
AppBarButtonTemplateSettings TemplateSettings { get; }
}
public class AppBarToggleButton : ToggleButton, ICommandBarElement, ICommandBarElement2 {
string KeyboardAcceleratorTextOverride { get; set; }
public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
AppBarToggleButtonTemplateSettings TemplateSettings { get; }
}
public sealed class ContentLinkChangedEventArgs
public enum ContentLinkChangeKind
public sealed class HandwritingPanelClosedEventArgs
public sealed class HandwritingPanelOpenedEventArgs
public enum HandwritingPanelPlacementAlignment
public class HandwritingView : Control
public class MediaTransportControls : Control {
bool IsCompactOverlayButtonVisible { get; set; }
public static DependencyProperty IsCompactOverlayButtonVisibleProperty { get; }
bool IsCompactOverlayEnabled { get; set; }
public static DependencyProperty IsCompactOverlayEnabledProperty { get; }
}
public class MenuFlyoutItem : MenuFlyoutItemBase {
string KeyboardAcceleratorTextOverride { get; set; }
public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
MenuFlyoutItemTemplateSettings TemplateSettings { get; }
}
public class NavigationView : ContentControl {
NavigationViewBackButtonVisible IsBackButtonVisible { get; set; }
public static DependencyProperty IsBackButtonVisibleProperty { get; }
bool IsBackEnabled { get; set; }
public static DependencyProperty IsBackEnabledProperty { get; }
string PaneTitle { get; set; }
public static DependencyProperty PaneTitleProperty { get; }
event TypedEventHandler<NavigationView, NavigationViewBackRequestedEventArgs> BackRequested;
event TypedEventHandler<NavigationView, object> PaneClosed;
event TypedEventHandler<NavigationView, NavigationViewPaneClosingEventArgs> PaneClosing;
event TypedEventHandler<NavigationView, object> PaneOpened;
event TypedEventHandler<NavigationView, object> PaneOpening;
}
public enum NavigationViewBackButtonVisible
public sealed class NavigationViewBackRequestedEventArgs
public sealed class NavigationViewPaneClosingEventArgs
public class RefreshContainer : ContentControl
public sealed class RefreshInteractionRatioChangedEventArgs
public enum RefreshPullDirection
public sealed class RefreshRequestedEventArgs
public sealed class RefreshStateChangedEventArgs
public class RefreshVisualizer : Control
public enum RefreshVisualizerOrientation
public enum RefreshVisualizerState
public class RichEditBox : Control {
SolidColorBrush ContentLinkBackgroundColor { get; set; }
public static DependencyProperty ContentLinkBackgroundColorProperty { get; }
SolidColorBrush ContentLinkForegroundColor { get; set; }
public static DependencyProperty ContentLinkForegroundColorProperty { get; }
ContentLinkProviderCollection ContentLinkProviders { get; set; }
public static DependencyProperty ContentLinkProvidersProperty { get; }
HandwritingView HandwritingView { get; set; }
public static DependencyProperty HandwritingViewProperty { get; }
bool IsHandwritingViewEnabled { get; set; }
public static DependencyProperty IsHandwritingViewEnabledProperty { get; }
event TypedEventHandler<RichEditBox, ContentLinkChangedEventArgs> ContentLinkChanged;
event TypedEventHandler<RichEditBox, ContentLinkInvokedEventArgs> ContentLinkInvoked;
}
public class TextBox : Control {
HandwritingView HandwritingView { get; set; }
public static DependencyProperty HandwritingViewProperty { get; }
bool IsHandwritingViewEnabled { get; set; }
public static DependencyProperty IsHandwritingViewEnabledProperty { get; }
}
public class TreeView : Control
public sealed class TreeViewCollapsedEventArgs
public sealed class TreeViewExpandingEventArgs
public class TreeViewItem : ListViewItem
public sealed class TreeViewItemInvokedEventArgs
public class TreeViewItemTemplateSettings : DependencyObject
public class TreeViewList : ListView
public class TreeViewNode : DependencyObject
public enum TreeViewSelectionMode
public sealed class WebView : FrameworkElement {
event TypedEventHandler<WebView, WebViewSeparateProcessLostEventArgs> SeparateProcessLost;
}
public enum WebViewExecutionMode {
SeparateProcess = 2,
}
public enum WebViewPermissionType {
Screen = 5,
WebVR = 6,
}
public sealed class WebViewSeparateProcessLostEventArgs
}
namespace Windows.UI.Xaml.Controls.Maps {
public sealed class MapControl : Control {
string Region { get; set; }
public static DependencyProperty RegionProperty { get; }
}
public class MapElement : DependencyObject {
bool IsEnabled { get; set; }
public static DependencyProperty IsEnabledProperty { get; }
}
}
namespace Windows.UI.Xaml.Controls.Primitives {
public sealed class AppBarButtonTemplateSettings : DependencyObject
public sealed class AppBarToggleButtonTemplateSettings : DependencyObject
public sealed class MenuFlyoutItemTemplateSettings : DependencyObject
}
namespace Windows.UI.Xaml.Documents {
public sealed class ContactContentLinkProvider : ContentLinkProvider
public sealed class ContentLink : Inline
public sealed class ContentLinkInvokedEventArgs
public class ContentLinkProvider : DependencyObject
public sealed class ContentLinkProviderCollection : IIterable<ContentLinkProvider>, IVector<ContentLinkProvider>
public sealed class PlaceContentLinkProvider : ContentLinkProvider
}
namespace Windows.UI.Xaml.Hosting {
public sealed class XamlBridge : IClosable
}
namespace Windows.UI.Xaml.Input {
public sealed class FocusManager {
public static IAsyncOperation<FocusMovementResult> TryFocusAsync(DependencyObject element, FocusState value);
public static IAsyncOperation<FocusMovementResult> TryMoveFocusAsync(FocusNavigationDirection focusNavigationDirection);
public static IAsyncOperation<FocusMovementResult> TryMoveFocusAsync(FocusNavigationDirection focusNavigationDirection, FindNextElementOptions focusNavigationOptions);
}
public sealed class FocusMovementResult
public sealed class GettingFocusEventArgs : RoutedEventArgs {
bool TryCancel();
bool TrySetNewFocusedElement(DependencyObject element);
}
public sealed class KeyboardAcceleratorInvokedEventArgs {
KeyboardAccelerator KeyboardAccelerator { get; }
}
public enum KeyboardAcceleratorPlacementMode
public sealed class LosingFocusEventArgs : RoutedEventArgs {
bool TryCancel();
bool TrySetNewFocusedElement(DependencyObject element);
}
}
namespace Windows.UI.Xaml.Media {
public sealed class CompositionTarget {
public static event EventHandler<RenderedEventArgs> Rendered;
}
public sealed class RenderedEventArgs
}
namespace Windows.Web.UI {
public interface IWebViewControl
public sealed class WebViewControlContentLoadingEventArgs
public sealed class WebViewControlDeferredPermissionRequest
public sealed class WebViewControlDOMContentLoadedEventArgs
public sealed class WebViewControlLongRunningScriptDetectedEventArgs
public sealed class WebViewControlNavigationCompletedEventArgs
public sealed class WebViewControlNavigationStartingEventArgs
public sealed class WebViewControlNewWindowRequestedEventArgs
public sealed class WebViewControlPermissionRequest
public sealed class WebViewControlPermissionRequestedEventArgs
public enum WebViewControlPermissionState
public enum WebViewControlPermissionType
public sealed class WebViewControlScriptNotifyEventArgs
public sealed class WebViewControlSettings
public sealed class WebViewControlUnsupportedUriSchemeIdentifiedEventArgs
public sealed class WebViewControlUnviewableContentIdentifiedEventArgs
public sealed class WebViewControlWebResourceRequestedEventArgs
}
namespace Windows.Web.UI.Interop {
public sealed class WebViewControl : IWebViewControl
public sealed class WebViewControlAcceleratorKeyPressedEventArgs
public enum WebViewControlAcceleratorKeyRoutingStage
public enum WebViewControlMoveFocusReason
public sealed class WebViewControlMoveFocusRequestedEventArgs
public sealed class WebViewControlProcess
public enum WebViewControlProcessCapabilityState
public sealed class WebViewControlProcessOptions
}