Category Archives: Mobile

Auto Added by WPeMatico

Windows 10 SDK Preview Build 17723 available now! – Windows Developer Blog

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 17723 or greater). The Preview SDK Build 17723 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 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 build 1803 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 only install on Windows 10 Insider Preview builds.
In order to assist with script access to the SDK, the ISO will also be able to be accessed through the following URL: once the static URL is published.
C++/WinRT Update for build 17709 and beyond:
This update introduces many improvements and fixes for C++/WinRT. Notably, it introduces the ability to build C++/WinRT without any dependency on the Windows SDK. This isn’t particularly interesting to the OS developer, but even in the OS repo it provides benefits because it does not itself include any Windows headers. Thus, a developer will typically pull in fewer or no dependencies inadvertently. This also means a dramatic reduction in the number of macros that a C++/WinRT developer must guard against. Removing the dependency on the Windows headers means that C++/WinRT is more portable and standards compliant and furthers our efforts to make it a cross-compiler and cross-platform library. It also means that the C++/WinRT headers will never be mangled by macros. If you previously relied on C++/WinRT to include various Windows headers that you will now have to include them yourself. It has always been good practice to always include any headers you depend on explicitly and not rely on another library to include them for you.
Support get_strong and get_weak to create delegates: This update allows a developer to use either get_strong or get_weak instead of a raw this pointer when creating a delegate pointing to a member function.
Add async cancellation callback: The most frequently requested feature for C++/WinRT’s coroutine support has been the addition of a cancellation callback.
Simplify the use of APIs expecting IBuffer parameters: Although most APIs prefer collections or arrays, enough APIs rely on IBuffer that it should be easier to use such APIs from C++. This update provides direct access to the data behind an IBuffer implementation using the same data naming convention used by the C++ standard library containers. This also avoids colliding with metadata names that conventionally begin with an uppercase letter.
Conformance: Improved support for Clang and Visual C++’s stricter conformance modes.
Improved code gen: Various improvements to reduce code size, improve inlining, and optimize factory caching.
Remove unnecessary recursion: When the command line refers to a folder rather than a specific winmd, cppwinrt will no longer search recursively for winmd files. It causes performance problems in the OS build and can lead to usage errors that are hard to diagnose when developers inadvertently cause cppwinrt to consume more winmds than expected. The cppwinrt compiler also now handles duplicates more intelligently, making it more resilient to user error and poorly-formed winmd files.
Declare both WINRT_CanUnloadNow and WINRT_GetActivationFactory in base.h: Callers don’t need to declare them directly. Their signatures have also changed, amounting to a breaking change. The declarations alleviate most of the pain of this change. The change is necessitated by the fact that C++/WinRT no longer depends on the Windows headers and this change removes the dependency on the types from the Windows headers.
Harden smart pointers: The event revokers didn’t revoke when move-assigned a new value. This lead me to take a closer look at the smart pointer classes and I noticed that they were not reliably handling self-assignment. This is rooted in the com_ptr class template that most of the others rely on. I fixed com_ptr and updated the event revokers to handle move semantics correctly to ensure that they revoke upon assignment. The handle class template has also been hardened by the removal of the implicit constructor that made it easy to write incorrect code. This also turned bugs in the OS into compiler errors fixed in this PR.
Breaking Changes
Support for non-WinRT interfaces is disabled by default. To enable, simply #include before any C++/WinRT headers.
winrt::get_abi(winrt::hstring) now returns void* instead of HSTRING. Code requiring the HSTRING ABI can simply use a static_cast.
winrt::put_abi(winrt::hstring) returns void** instead of HSTRING*. Code requiring the HSTRING ABI can simply use a reinterpret_cast.
HRESULT is now projected as winrt::hresult. Code requiring an HRESULT can simply static_cast if you need to do type checking or support type traits, but it is otherwise convertible as long as is included first.
GUID is now projected as winrt::guid. Code implementing APIs with GUID parameters must use winrt::guid instead, but it is otherwise convertible as long as is included first.
The signatures of WINRT_CanUnloadNow and WINRT_GetActivationFactory has changed. Code must not declare these functions at all and instead include winrt/base.h to include their declarations.
The winrt::handle constructor is now explicit. Code assigning a raw handle value must call the attach method instead.
winrt::clock::from_FILETIME has been deprecated. Code should use winrt::clock::from_file_time instead.
What’s New:
MSIX Support
It’s finally here! You can now package your applications as MSIX! These applications can be installed and run on any device with 17682 build or later.
To package your application with MSIX, use the MakeAppx tool. To install the application – just click on the MSIX file. To understand more about MSIX, watch this introductory video: link
Feedback and comments are welcome on our MSIX community:
MSIX is not currently supported by the App Certification Kit nor the Microsoft Store at this time.
We’ve made some important changes to the C/C++ ETW code generation of mc.exe (Message Compiler):
The “-mof” parameter is deprecated. This parameter instructs MC.exe to generate ETW code that is compatible with Windows XP and earlier. Support for the “-mof” parameter will be removed in a future version of mc.exe.
As long as the “-mof” parameter is not used, the generated C/C++ header is now compatible with both kernel-mode and user-mode, regardless of whether “-km” or “-um” was specified on the command line. The header will use the _ETW_KM_ macro to automatically determine whether it is being compiled for kernel-mode or user-mode and will call the appropriate ETW APIs for each mode.
The only remaining difference between “-km” and “-um” is that the EventWrite[EventName] macros generated with “-km” have an Activity ID parameter while the EventWrite[EventName] macros generated with “-um” do not have an Activity ID parameter.
The EventWrite[EventName] macros now default to calling EventWriteTransfer (user mode) or EtwWriteTransfer (kernel mode). Previously, the EventWrite[EventName] macros defaulted to calling EventWrite (user mode) or EtwWrite (kernel mode).
The generated header now supports several customization macros. For example, you can set the MCGEN_EVENTWRITETRANSFER macro if you need the generated macros to call something other than EventWriteTransfer.
The manifest supports new attributes.
Event “name”: non-localized event name.
Event “attributes”: additional key-value metadata for an event such as filename, line number, component name, function name.
Event “tags”: 28-bit value with user-defined semantics (per-event).
Field “tags”: 28-bit value with user-defined semantics (per-field – can be applied to “data” or “struct” elements).

You can now define “provider traits” in the manifest (e.g. provider group). If provider traits are used in the manifest, the EventRegister[ProviderName] macro will automatically register them.
MC will now report an error if a localized message file is missing a string. (Previously MC would silently generate a corrupt message resource.)
MC can now generate Unicode (utf-8 or utf-16) output with the “-cp utf-8” or “-cp utf-16” parameters.
Known Issues:
The SDK headers are generated with types in the “ABI” namespace. This is done to avoid conflicts with C++/CX and C++/WinRT clients that need to consume types directly at the ABI layer[1]. By default, types emitted by MIDL are *not* put in the ABI namespace, however this has the potential to introduce conflicts from teams attempting to consume ABI types from Windows WinRT MIDL generated headers and non-Windows WinRT MIDL generated headers (this is especially challenging if the non-Windows header references Windows types).
To ensure that developers have a consistent view of the WinRT API surface, validation has been added to the generated headers to ensure that the ABI prefix is consistent between the Windows headers and user generated headers. If you encounter an error like:
5>c:program files (x86)windows error C2220: warning treated as error – no ‘object’ file generated
5>c:program files (x86)windows warning C4005: ‘CHECK_NS_PREFIX_STATE’: macro redefinition
5>g:(41): note: see previous definition of ‘CHECK_NS_PREFIX_STATE’
It means that some of your MIDL generated headers are inconsistent with the system generated headers.
There are two ways to fix this:
Preferred: Compile your IDL file with the /ns_prefix MIDL command line switch. This will cause all your types to be moved to the ABI namespace consistent with the Windows headers. This may require code changes in your code however.
Alternate: Add #define DISABLE_NS_PREFIX_CHECKS before including the Windows headers. This will suppress the validation.
API Updates, Additions and Removals
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 17134.  The APIs listed below have been removed.

namespace Windows.AI.MachineLearning {
public interface ILearningModelFeatureDescriptor
public interface ILearningModelFeatureValue
public interface ILearningModelOperatorProvider
public sealed class ImageFeatureDescriptor : ILearningModelFeatureDescriptor
public sealed class ImageFeatureValue : ILearningModelFeatureValue
public interface ITensor : ILearningModelFeatureValue
public sealed class LearningModel : IClosable
public sealed class LearningModelBinding : IIterable, IMapView
public sealed class LearningModelDevice
public enum LearningModelDeviceKind
public sealed class LearningModelEvaluationResult
public enum LearningModelFeatureKind
public sealed class LearningModelSession : IClosable
public struct MachineLearningContract
public sealed class MapFeatureDescriptor : ILearningModelFeatureDescriptor
public sealed class SequenceFeatureDescriptor : ILearningModelFeatureDescriptor
public sealed class TensorBoolean : ILearningModelFeatureValue, ITensor
public sealed class TensorDouble : ILearningModelFeatureValue, ITensor
public sealed class TensorFeatureDescriptor : ILearningModelFeatureDescriptor
public sealed class TensorFloat : ILearningModelFeatureValue, ITensor
public sealed class TensorFloat16Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorInt16Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorInt32Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorInt64Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorInt8Bit : ILearningModelFeatureValue, ITensor
public enum TensorKind
public sealed class TensorString : ILearningModelFeatureValue, ITensor
public sealed class TensorUInt16Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorUInt32Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorUInt64Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorUInt8Bit : ILearningModelFeatureValue, ITensor
namespace Windows.ApplicationModel {
public sealed class AppInstallerInfo
public sealed class LimitedAccessFeatureRequestResult
public static class LimitedAccessFeatures
public enum LimitedAccessFeatureStatus
public sealed class Package {
IAsyncOperation CheckUpdateAvailabilityAsync();
AppInstallerInfo GetAppInstallerInfo();
public enum PackageUpdateAvailability
public sealed class PackageUpdateAvailabilityResult
namespace Windows.ApplicationModel.Calls {
public sealed class VoipCallCoordinator {
IAsyncOperation ReserveCallResourcesAsync();
namespace Windows.ApplicationModel.Chat {
public static class ChatCapabilitiesManager {
public static IAsyncOperation GetCachedCapabilitiesAsync(string address, string transportId);
public static IAsyncOperation GetCapabilitiesFromNetworkAsync(string address, string transportId);
public static class RcsManager {
public static event EventHandler TransportListChanged;
namespace Windows.ApplicationModel.DataTransfer {
public static class Clipboard {
public static event EventHandler HistoryChanged;
public static event EventHandler HistoryEnabledChanged;
public static event EventHandler RoamingEnabledChanged;
public static bool ClearHistory();
public static bool DeleteItemFromHistory(ClipboardHistoryItem item);
public static IAsyncOperation GetHistoryItemsAsync();
public static bool IsHistoryEnabled();
public static bool IsRoamingEnabled();
public static bool SetContentWithOptions(DataPackage content, ClipboardContentOptions options);
public static SetHistoryItemAsContentStatus SetHistoryItemAsContent(ClipboardHistoryItem item);
public sealed class ClipboardContentOptions
public sealed class ClipboardHistoryChangedEventArgs
public sealed class ClipboardHistoryItem
public sealed class ClipboardHistoryItemsResult
public enum ClipboardHistoryItemsResultStatus
public sealed class DataPackagePropertySetView : IIterable, IMapView {
bool IsFromRoamingClipboard { get; }
string SourceDisplayName { get; }
public enum SetHistoryItemAsContentStatus
namespace Windows.ApplicationModel.Store.Preview {
public enum DeliveryOptimizationDownloadMode
public enum DeliveryOptimizationDownloadModeSource
public sealed class DeliveryOptimizationSettings
public static class StoreConfiguration {
public static bool IsPinToDesktopSupported();
public static bool IsPinToStartSupported();
public static bool IsPinToTaskbarSupported();
public static void PinToDesktop(string appPackageFamilyName);
public static void PinToDesktopForUser(User user, string appPackageFamilyName);
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
public enum AppInstallationToastNotificationMode
public sealed class AppInstallItem {
AppInstallationToastNotificationMode CompletedInstallToastNotificationMode { get; set; }
AppInstallationToastNotificationMode InstallInProgressToastNotificationMode { get; set; }
bool PinToDesktopAfterInstall { get; set; }
bool PinToStartAfterInstall { get; set; }
bool PinToTaskbarAfterInstall { get; set; }
public sealed class AppInstallManager {
bool CanInstallForAllUsers { get; }
public sealed class AppInstallOptions {
string CampaignId { get; set; }
AppInstallationToastNotificationMode CompletedInstallToastNotificationMode { get; set; }
string ExtendedCampaignId { get; set; }
bool InstallForAllUsers { get; set; }
AppInstallationToastNotificationMode InstallInProgressToastNotificationMode { get; set; }
bool PinToDesktopAfterInstall { get; set; }
bool PinToStartAfterInstall { get; set; }
bool PinToTaskbarAfterInstall { get; set; }
bool StageButDoNotInstall { get; set; }
public sealed class AppUpdateOptions {
bool AutomaticallyDownloadAndInstallUpdateIfFound { get; set; }
namespace Windows.ApplicationModel.UserActivities {
public sealed class UserActivity {
bool IsRoamable { get; set; }
namespace Windows.Data.Text {
public sealed class TextPredictionGenerator {
CoreTextInputScope InputScope { get; set; }
IAsyncOperation GetCandidatesAsync(string input, uint maxCandidates, TextPredictionOptions predictionOptions, IIterable previousStrings);
IAsyncOperation GetNextWordCandidatesAsync(uint maxCandidates, IIterable previousStrings);
public enum TextPredictionOptions : uint
namespace Windows.Devices.Display.Core {
public sealed class DisplayAdapter
public enum DisplayBitsPerChannel : uint
public sealed class DisplayDevice
public enum DisplayDeviceCapability
public sealed class DisplayFence
public sealed class DisplayManager : IClosable
public sealed class DisplayManagerChangedEventArgs
public sealed class DisplayManagerDisabledEventArgs
public sealed class DisplayManagerEnabledEventArgs
public enum DisplayManagerOptions : uint
public sealed class DisplayManagerPathsFailedOrInvalidatedEventArgs
public enum DisplayManagerResult
public sealed class DisplayManagerResultWithState
public sealed class DisplayModeInfo
public enum DisplayModeQueryOptions : uint
public sealed class DisplayPath
public enum DisplayPathScaling
public enum DisplayPathStatus
public struct DisplayPresentationRate
public sealed class DisplayPrimaryDescription
public enum DisplayRotation
public sealed class DisplayScanout
public sealed class DisplaySource
public sealed class DisplayState
public enum DisplayStateApplyOptions : uint
public enum DisplayStateFunctionalizeOptions : uint
public sealed class DisplayStateOperationResult
public enum DisplayStateOperationStatus
public sealed class DisplaySurface
public sealed class DisplayTarget
public enum DisplayTargetPersistence
public sealed class DisplayTask
public sealed class DisplayTaskPool
public enum DisplayTaskSignalKind
public sealed class DisplayView
public sealed class DisplayWireFormat
public enum DisplayWireFormatColorSpace
public enum DisplayWireFormatEotf
public enum DisplayWireFormatHdrMetadata
public enum DisplayWireFormatPixelEncoding
namespace Windows.Devices.Enumeration {
public enum DeviceInformationKind {
DevicePanel = 8,
public sealed class DeviceInformationPairing {
public static bool TryRegisterForAllInboundPairingRequestsWithProtectionLevel(DevicePairingKinds pairingKindsSupported, DevicePairingProtectionLevel minProtectionLevel);
namespace Windows.Devices.Enumeration.Pnp {
public enum PnpObjectType {
DevicePanel = 8,
namespace Windows.Devices.Lights {
public sealed class LampArray
public enum LampArrayKind
public sealed class LampInfo
public enum LampPurposes : uint
namespace Windows.Devices.Lights.Effects {
public interface ILampArrayEffect
public sealed class LampArrayBitmapEffect : ILampArrayEffect
public sealed class LampArrayBitmapRequestedEventArgs
public sealed class LampArrayBlinkEffect : ILampArrayEffect
public sealed class LampArrayColorRampEffect : ILampArrayEffect
public sealed class LampArrayCustomEffect : ILampArrayEffect
public enum LampArrayEffectCompletionBehavior
public sealed class LampArrayEffectPlaylist : IIterable, IVectorView
public enum LampArrayEffectStartMode
public enum LampArrayRepetitionMode
public sealed class LampArraySolidEffect : ILampArrayEffect
public sealed class LampArrayUpdateRequestedEventArgs
namespace Windows.Devices.PointOfService {
public sealed class BarcodeScannerCapabilities {
bool IsVideoPreviewSupported { get; }
public sealed class ClaimedBarcodeScanner : IClosable {
event TypedEventHandler Closed;
public sealed class ClaimedBarcodeScannerClosedEventArgs
public sealed class ClaimedCashDrawer : IClosable {
event TypedEventHandler Closed;
public sealed class ClaimedCashDrawerClosedEventArgs
public sealed class ClaimedLineDisplay : IClosable {
event TypedEventHandler Closed;
public sealed class ClaimedLineDisplayClosedEventArgs
public sealed class ClaimedMagneticStripeReader : IClosable {
event TypedEventHandler Closed;
public sealed class ClaimedMagneticStripeReaderClosedEventArgs
public sealed class ClaimedPosPrinter : IClosable {
event TypedEventHandler Closed;
public sealed class ClaimedPosPrinterClosedEventArgs
namespace Windows.Devices.PointOfService.Provider {
public sealed class BarcodeScannerDisableScannerRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
public sealed class BarcodeScannerEnableScannerRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
public sealed class BarcodeScannerFrameReader : IClosable
public sealed class BarcodeScannerFrameReaderFrameArrivedEventArgs
public sealed class BarcodeScannerGetSymbologyAttributesRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
public sealed class BarcodeScannerHideVideoPreviewRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
public sealed class BarcodeScannerProviderConnection : IClosable {
IAsyncOperation CreateFrameReaderAsync();
IAsyncOperation CreateFrameReaderAsync(BitmapPixelFormat preferredFormat);
IAsyncOperation CreateFrameReaderAsync(BitmapPixelFormat preferredFormat, BitmapSize preferredSize);
public sealed class BarcodeScannerSetActiveSymbologiesRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
public sealed class BarcodeScannerSetSymbologyAttributesRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
public sealed class BarcodeScannerStartSoftwareTriggerRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
public sealed class BarcodeScannerStopSoftwareTriggerRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
public sealed class BarcodeScannerVideoFrame : IClosable
namespace Windows.Devices.Sensors {
public sealed class HingeAngleReading
public sealed class HingeAngleSensor
public sealed class HingeAngleSensorReadingChangedEventArgs
public sealed class SimpleOrientationSensor {
public static IAsyncOperation FromIdAsync(string deviceId);
public static string GetDeviceSelector();
namespace Windows.Devices.SmartCards {
public static class KnownSmartCardAppletIds
public sealed class SmartCardAppletIdGroup {
string Description { get; set; }
IRandomAccessStreamReference Logo { get; set; }
ValueSet Properties { get; }
bool SecureUserAuthenticationRequired { get; set; }
public sealed class SmartCardAppletIdGroupRegistration {
string SmartCardReaderId { get; }
IAsyncAction SetPropertiesAsync(ValueSet props);
namespace Windows.Devices.WiFi {
public enum WiFiPhyKind {
HE = 10,
namespace Windows.Foundation {
public static class GuidHelper
namespace Windows.Globalization {
public static class CurrencyIdentifiers {
public static string MRU { get; }
public static string SSP { get; }
public static string STN { get; }
public static string VES { get; }
namespace Windows.Graphics.Capture {
public sealed class Direct3D11CaptureFramePool : IClosable {
public static Direct3D11CaptureFramePool CreateFreeThreaded(IDirect3DDevice device, DirectXPixelFormat pixelFormat, int numberOfBuffers, SizeInt32 size);
public sealed class GraphicsCaptureItem {
public static GraphicsCaptureItem CreateFromVisual(Visual visual);
namespace Windows.Graphics.Display.Core {
public enum HdmiDisplayHdrOption {
DolbyVisionLowLatency = 3,
public sealed class HdmiDisplayMode {
bool IsDolbyVisionLowLatencySupported { get; }
namespace Windows.Graphics.Holographic {
public sealed class HolographicCamera {
bool IsHardwareContentProtectionEnabled { get; set; }
bool IsHardwareContentProtectionSupported { get; }
public sealed class HolographicQuadLayerUpdateParameters {
bool CanAcquireWithHardwareProtection { get; }
IDirect3DSurface AcquireBufferToUpdateContentWithHardwareProtection();
namespace Windows.Graphics.Imaging {
public sealed class BitmapDecoder : IBitmapFrame, IBitmapFrameWithSoftwareBitmap {
public static Guid HeifDecoderId { get; }
public static Guid WebpDecoderId { get; }
public sealed class BitmapEncoder {
public static Guid HeifEncoderId { get; }
namespace Windows.Management.Deployment {
public enum DeploymentOptions : uint {
ForceUpdateFromAnyVersion = (uint)262144,
public sealed class PackageManager {
IAsyncOperationWithProgress DeprovisionPackageForAllUsersAsync(string packageFamilyName);
public enum RemovalOptions : uint {
RemoveForAllUsers = (uint)524288,
namespace Windows.Management.Policies {
public static class NamedPolicy {
public static IAsyncAction ClearAllPoliciesAsync();
public static IAsyncAction ClearAllPoliciesAsync(string accountId);
public static NamedPolicySetter TryCreatePolicySetter(string accountId);
public static NamedPolicySetter TryCreatePolicySetterForUser(User user, string accountId);
public sealed class NamedPolicySetter
namespace Windows.Media.Audio {
public sealed class CreateAudioDeviceInputNodeResult {
HResult ExtendedError { get; }
public sealed class CreateAudioDeviceOutputNodeResult {
HResult ExtendedError { get; }
public sealed class CreateAudioFileInputNodeResult {
HResult ExtendedError { get; }
public sealed class CreateAudioFileOutputNodeResult {
HResult ExtendedError { get; }
public sealed class CreateAudioGraphResult {
HResult ExtendedError { get; }
public sealed class CreateMediaSourceAudioInputNodeResult {
HResult ExtendedError { get; }
public enum MixedRealitySpatialAudioFormatPolicy
public sealed class SetDefaultSpatialAudioFormatResult
public enum SetDefaultSpatialAudioFormatStatus
public sealed class SpatialAudioDeviceConfiguration
public sealed class SpatialAudioFormatConfiguration
public static class SpatialAudioFormatSubtype
namespace Windows.Media.Control {
public sealed class CurrentSessionChangedEventArgs
public sealed class GlobalSystemMediaTransportControlsSession
public sealed class GlobalSystemMediaTransportControlsSessionManager
public sealed class GlobalSystemMediaTransportControlsSessionMediaProperties
public sealed class GlobalSystemMediaTransportControlsSessionPlaybackControls
public sealed class GlobalSystemMediaTransportControlsSessionPlaybackInfo
public enum GlobalSystemMediaTransportControlsSessionPlaybackStatus
public sealed class GlobalSystemMediaTransportControlsSessionTimelineProperties
public sealed class MediaPropertiesChangedEventArgs
public sealed class PlaybackInfoChangedEventArgs
public sealed class SessionsChangedEventArgs
public sealed class TimelinePropertiesChangedEventArgs
namespace Windows.Media.Core {
public sealed class MediaStreamSample {
IDirect3DSurface Direct3D11Surface { get; }
public static MediaStreamSample CreateFromDirect3D11Surface(IDirect3DSurface surface, TimeSpan timestamp);
namespace Windows.Media.Devices.Core {
public sealed class CameraIntrinsics {
public CameraIntrinsics(Vector2 focalLength, Vector2 principalPoint, Vector3 radialDistortion, Vector2 tangentialDistortion, uint imageWidth, uint imageHeight);
namespace Windows.Media.Import {
public enum PhotoImportContentTypeFilter {
ImagesAndVideosFromCameraRoll = 3,
public sealed class PhotoImportItem {
string Path { get; }
namespace Windows.Media.MediaProperties {
public sealed class ImageEncodingProperties : IMediaEncodingProperties {
public static ImageEncodingProperties CreateHeif();
public static class MediaEncodingSubtypes {
public static string Heif { get; }
namespace Windows.Media.Protection.PlayReady {
public static class PlayReadyStatics {
public static IReference HardwareDRMDisabledAtTime { get; }
public static IReference HardwareDRMDisabledUntilTime { get; }
public static void ResetHardwareDRMDisabled();
namespace Windows.Media.Streaming.Adaptive {
public enum AdaptiveMediaSourceResourceType {
MediaSegmentIndex = 5,
namespace Windows.Networking.BackgroundTransfer {
public enum BackgroundTransferPriority {
Low = 2,
namespace Windows.Networking.Connectivity {
public sealed class ConnectionProfile {
bool CanDelete { get; }
IAsyncOperation TryDeleteAsync();
public enum ConnectionProfileDeleteStatus
namespace Windows.Networking.NetworkOperators {
public enum ESimOperationStatus {
CardGeneralFailure = 13,
ConfirmationCodeMissing = 14,
EidMismatch = 18,
InvalidMatchingId = 15,
NoCorrespondingRequest = 23,
NoEligibleProfileForThisDevice = 16,
OperationAborted = 17,
OperationProhibitedByProfileClass = 21,
ProfileNotAvailableForNewBinding = 19,
ProfileNotPresent = 22,
ProfileNotReleasedByOperator = 20,
namespace Windows.Perception {
public sealed class PerceptionTimestamp {
TimeSpan SystemRelativeTargetTime { get; }
public static class PerceptionTimestampHelper {
public static PerceptionTimestamp FromSystemRelativeTargetTime(TimeSpan targetTime);
namespace Windows.Perception.Spatial {
public sealed class SpatialAnchorExporter
public enum SpatialAnchorExportPurpose
public sealed class SpatialAnchorExportSufficiency
public sealed class SpatialLocation {
Vector3 AbsoluteAngularAccelerationAxisAngle { get; }
Vector3 AbsoluteAngularVelocityAxisAngle { get; }
namespace Windows.Perception.Spatial.Preview {
public static class SpatialGraphInteropPreview
namespace Windows.Security.DataProtection {
public enum UserDataAvailability
public sealed class UserDataAvailabilityStateChangedEventArgs
public sealed class UserDataBufferUnprotectResult
public enum UserDataBufferUnprotectStatus
public sealed class UserDataProtectionManager
public sealed class UserDataStorageItemProtectionInfo
public enum UserDataStorageItemProtectionStatus
namespace Windows.Services.Cortana {
public sealed class CortanaActionableInsights
public sealed class CortanaActionableInsightsOptions
namespace Windows.Services.Store {
public sealed class StoreAppLicense {
bool IsDiscLicense { get; }
public sealed class StoreContext {
IAsyncOperation RequestRateAndReviewAppAsync();
IAsyncOperation SetInstallOrderForAssociatedStoreQueueItemsAsync(IIterable items);
public sealed class StoreQueueItem {
IAsyncAction CancelInstallAsync();
IAsyncAction PauseInstallAsync();
IAsyncAction ResumeInstallAsync();
public sealed class StoreRateAndReviewResult
public enum StoreRateAndReviewStatus
namespace Windows.Storage.Provider {
public enum StorageProviderHydrationPolicyModifier : uint {
AutoDehydrationAllowed = (uint)4,
public sealed class StorageProviderSyncRootInfo {
Guid ProviderId { get; set; }
namespace Windows.System {
public sealed class AppUriHandlerHost
public sealed class AppUriHandlerRegistration
public sealed class AppUriHandlerRegistrationManager
public static class Launcher {
public static IAsyncOperation LaunchFolderPathAsync(string path);
public static IAsyncOperation LaunchFolderPathAsync(string path, FolderLauncherOptions options);
public static IAsyncOperation LaunchFolderPathForUserAsync(User user, string path);
public static IAsyncOperation LaunchFolderPathForUserAsync(User user, string path, FolderLauncherOptions options);
namespace Windows.System.Preview {
public enum HingeState
public sealed class TwoPanelHingedDevicePosturePreview
public sealed class TwoPanelHingedDevicePosturePreviewReading
public sealed class TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs
namespace Windows.System.Profile {
public enum SystemOutOfBoxExperienceState
public static class SystemSetupInfo
public static class WindowsIntegrityPolicy
namespace Windows.System.Profile.SystemManufacturers {
public sealed class SystemSupportDeviceInfo
public static class SystemSupportInfo {
public static SystemSupportDeviceInfo LocalDeviceInfo { get; }
namespace Windows.System.RemoteSystems {
public sealed class RemoteSystem {
IVectorView Apps { get; }
public sealed class RemoteSystemApp
public sealed class RemoteSystemAppRegistration
public sealed class RemoteSystemConnectionInfo
public sealed class RemoteSystemConnectionRequest {
RemoteSystemApp RemoteSystemApp { get; }
public static RemoteSystemConnectionRequest CreateForApp(RemoteSystemApp remoteSystemApp);
public sealed class RemoteSystemWebAccountFilter : IRemoteSystemFilter
namespace Windows.System.Update {
public enum SystemUpdateAttentionRequiredReason
public sealed class SystemUpdateItem
public enum SystemUpdateItemState
public sealed class SystemUpdateLastErrorInfo
public static class SystemUpdateManager
public enum SystemUpdateManagerState
public enum SystemUpdateStartInstallAction
namespace Windows.System.UserProfile {
public sealed class AssignedAccessSettings
namespace Windows.UI.Accessibility {
public sealed class ScreenReaderPositionChangedEventArgs
public sealed class ScreenReaderService
namespace Windows.UI.Composition {
public enum AnimationPropertyAccessMode
public sealed class AnimationPropertyInfo : CompositionObject
public sealed class BooleanKeyFrameAnimation : KeyFrameAnimation
public class CompositionAnimation : CompositionObject, ICompositionAnimationBase {
void SetExpressionReferenceParameter(string parameterName, IAnimationObject source);
public enum CompositionBatchTypes : uint {
AllAnimations = (uint)5,
InfiniteAnimation = (uint)4,
public sealed class CompositionGeometricClip : CompositionClip
public class CompositionGradientBrush : CompositionBrush {
CompositionMappingMode MappingMode { get; set; }
public enum CompositionMappingMode
public class CompositionObject : IAnimationObject, IClosable {
void PopulatePropertyInfo(string propertyName, AnimationPropertyInfo propertyInfo);
public static void StartAnimationGroupWithIAnimationObject(IAnimationObject target, ICompositionAnimationBase animation);
public static void StartAnimationWithIAnimationObject(IAnimationObject target, string propertyName, CompositionAnimation animation);
public sealed class Compositor : IClosable {
BooleanKeyFrameAnimation CreateBooleanKeyFrameAnimation();
CompositionGeometricClip CreateGeometricClip();
CompositionGeometricClip CreateGeometricClip(CompositionGeometry geometry);
RedirectVisual CreateRedirectVisual();
RedirectVisual CreateRedirectVisual(Visual source);
public interface IAnimationObject
public sealed class RedirectVisual : ContainerVisual
namespace Windows.UI.Composition.Interactions {
public sealed class InteractionSourceConfiguration : CompositionObject
public enum InteractionSourceRedirectionMode
public sealed class InteractionTracker : CompositionObject {
bool IsInertiaFromImpulse { get; }
int TryUpdatePosition(Vector3 value, InteractionTrackerClampingOption option);
int TryUpdatePositionBy(Vector3 amount, InteractionTrackerClampingOption option);
public enum InteractionTrackerClampingOption
public sealed class InteractionTrackerInertiaStateEnteredArgs {
bool IsInertiaFromImpulse { get; }
public class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
InteractionSourceConfiguration PointerWheelConfig { get; }
namespace Windows.UI.Input.Inking {
public enum HandwritingLineHeight
public sealed class PenAndInkSettings
public enum PenHandedness
namespace Windows.UI.Input.Inking.Preview {
public sealed class PalmRejectionDelayZonePreview : IClosable
namespace Windows.UI.Notifications {
public sealed class ScheduledToastNotificationShowingEventArgs
public sealed class ToastNotifier {
event TypedEventHandler ScheduledToastNotificationShowing;
namespace Windows.UI.Shell {
public enum SecurityAppKind
public sealed class SecurityAppManager
public struct SecurityAppManagerContract
public enum SecurityAppState
public enum SecurityAppSubstatus
public sealed class TaskbarManager {
IAsyncOperation IsSecondaryTilePinnedAsync(string tileId);
IAsyncOperation RequestPinSecondaryTileAsync(SecondaryTile secondaryTile);
IAsyncOperation TryUnpinSecondaryTileAsync(string tileId);
namespace Windows.UI.StartScreen {
public sealed class StartScreenManager {
IAsyncOperation ContainsSecondaryTileAsync(string tileId);
IAsyncOperation TryRemoveSecondaryTileAsync(string tileId);
namespace Windows.UI.Text {
public sealed class RichEditTextDocument : ITextDocument {
void ClearUndoRedoHistory();
namespace Windows.UI.Text.Core {
public sealed class CoreTextLayoutRequest {
CoreTextLayoutBounds LayoutBoundsVisualPixels { get; }
namespace Windows.UI.ViewManagement {
public enum ApplicationViewWindowingMode {
CompactOverlay = 3,
Maximized = 4,
namespace Windows.UI.ViewManagement.Core {
public sealed class CoreInputView {
bool TryHide();
bool TryShow();
bool TryShow(CoreInputViewKind type);
public enum CoreInputViewKind
namespace Windows.UI.WebUI {
public sealed class BackgroundActivatedEventArgs : IBackgroundActivatedEventArgs
public delegate void BackgroundActivatedEventHandler(object sender, IBackgroundActivatedEventArgs eventArgs);
public sealed class NewWebUIViewCreatedEventArgs
public static class WebUIApplication {
public static event BackgroundActivatedEventHandler BackgroundActivated;
public static event EventHandler NewWebUIViewCreated;
public sealed class WebUIView : IWebViewControl, IWebViewControl2
namespace Windows.UI.Xaml {
public class BrushTransition
public class ColorPaletteResources : ResourceDictionary
public class DataTemplate : FrameworkTemplate, IElementFactory {
UIElement GetElement(ElementFactoryGetArgs args);
void RecycleElement(ElementFactoryRecycleArgs args);
public sealed class DebugSettings {
bool FailFastOnErrors { get; set; }
public sealed class EffectiveViewportChangedEventArgs
public class ElementFactoryGetArgs
public class ElementFactoryRecycleArgs
public class FrameworkElement : UIElement {
bool IsLoaded { get; }
event TypedEventHandler EffectiveViewportChanged;
void InvalidateViewport();
public interface IElementFactory
public class ScalarTransition
public class UIElement : DependencyObject, IAnimationObject {
bool CanBeScrollAnchor { get; set; }
public static DependencyProperty CanBeScrollAnchorProperty { get; }
Vector3 CenterPoint { get; set; }
ScalarTransition OpacityTransition { get; set; }
float Rotation { get; set; }
Vector3 RotationAxis { get; set; }
ScalarTransition RotationTransition { get; set; }
Vector3 Scale { get; set; }
Vector3Transition ScaleTransition { get; set; }
Shadow Shadow { get; set; }
public static DependencyProperty ShadowProperty { get; }
Matrix4x4 TransformMatrix { get; set; }
Vector3 Translation { get; set; }
Vector3Transition TranslationTransition { get; set; }
void PopulatePropertyInfo(string propertyName, AnimationPropertyInfo propertyInfo);
virtual void PopulatePropertyInfoOverride(string propertyName, AnimationPropertyInfo animationPropertyInfo);
void StartAnimation(ICompositionAnimationBase animation);
void StopAnimation(ICompositionAnimationBase animation);
public class UIElementWeakCollection : IIterable, IVector
public class Vector3Transition
public enum Vector3TransitionComponents : uint
namespace Windows.UI.Xaml.Automation {
public sealed class AutomationElementIdentifiers {
public static AutomationProperty IsDialogProperty { get; }
public sealed class AutomationProperties {
public static DependencyProperty IsDialogProperty { get; }
public static bool GetIsDialog(DependencyObject element);
public static void SetIsDialog(DependencyObject element, bool value);
namespace Windows.UI.Xaml.Automation.Peers {
public class AppBarButtonAutomationPeer : ButtonAutomationPeer, IExpandCollapseProvider {
ExpandCollapseState ExpandCollapseState { get; }
void Collapse();
void Expand();
public class AutomationPeer : DependencyObject {
bool IsDialog();
virtual bool IsDialogCore();
public class MenuBarAutomationPeer : FrameworkElementAutomationPeer
public class MenuBarItemAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider, IInvokeProvider
namespace Windows.UI.Xaml.Controls {
public sealed class AnchorRequestedEventArgs
public class AppBarElementContainer : ContentControl, ICommandBarElement, ICommandBarElement2
public sealed class AutoSuggestBox : ItemsControl {
object Description { get; set; }
public static DependencyProperty DescriptionProperty { get; }
public enum BackgroundSizing
public sealed class Border : FrameworkElement {
BackgroundSizing BackgroundSizing { get; set; }
public static DependencyProperty BackgroundSizingProperty { get; }
BrushTransition BackgroundTransition { get; set; }
public class CalendarDatePicker : Control {
object Description { get; set; }
public static DependencyProperty DescriptionProperty { get; }
public class ComboBox : Selector {
object Description { get; set; }
public static DependencyProperty DescriptionProperty { get; }
bool IsEditable { get; set; }
public static DependencyProperty IsEditableProperty { get; }
string Text { get; set; }
Style TextBoxStyle { get; set; }
public static DependencyProperty TextBoxStyleProperty { get; }
public static DependencyProperty TextProperty { get; }
event TypedEventHandler TextSubmitted;
public sealed class ComboBoxTextSubmittedEventArgs
public class CommandBarFlyout : FlyoutBase
public class ContentPresenter : FrameworkElement {
BackgroundSizing BackgroundSizing { get; set; }
public static DependencyProperty BackgroundSizingProperty { get; }
BrushTransition BackgroundTransition { get; set; }
public class Control : FrameworkElement {
BackgroundSizing BackgroundSizing { get; set; }
public static DependencyProperty BackgroundSizingProperty { get; }
CornerRadius CornerRadius { get; set; }
public static DependencyProperty CornerRadiusProperty { get; }
public class DataTemplateSelector : IElementFactory {
UIElement GetElement(ElementFactoryGetArgs args);
void RecycleElement(ElementFactoryRecycleArgs args);
public class DatePicker : Control {
IReference SelectedDate { get; set; }
public static DependencyProperty SelectedDateProperty { get; }
event TypedEventHandler SelectedDateChanged;
public sealed class DatePickerSelectedValueChangedEventArgs
public class DropDownButton : Button
public class DropDownButtonAutomationPeer : ButtonAutomationPeer, IExpandCollapseProvider
public class Frame : ContentControl, INavigate {
bool IsNavigationStackEnabled { get; set; }
public static DependencyProperty IsNavigationStackEnabledProperty { get; }
bool NavigateToType(TypeName sourcePageType, object parameter, FrameNavigationOptions navigationOptions);
public class Grid : Panel {
BackgroundSizing BackgroundSizing { get; set; }
public static DependencyProperty BackgroundSizingProperty { get; }
public class IconSourceElement : IconElement
public sealed class InputPropertyAttribute : Attribute
public interface IScrollAnchorProvider
public class MenuBar : Control
public class MenuBarItem : Control
public class MenuBarItemFlyout : MenuFlyout
public class NavigationView : ContentControl {
UIElement ContentOverlay { get; set; }
public static DependencyProperty ContentOverlayProperty { get; }
bool IsPaneVisible { get; set; }
public static DependencyProperty IsPaneVisibleProperty { get; }
NavigationViewOverflowLabelMode OverflowLabelMode { get; set; }
public static DependencyProperty OverflowLabelModeProperty { get; }
UIElement PaneCustomContent { get; set; }
public static DependencyProperty PaneCustomContentProperty { get; }
NavigationViewPaneDisplayMode PaneDisplayMode { get; set; }
public static DependencyProperty PaneDisplayModeProperty { get; }
UIElement PaneHeader { get; set; }
public static DependencyProperty PaneHeaderProperty { get; }
NavigationViewSelectionFollowsFocus SelectionFollowsFocus { get; set; }
public static DependencyProperty SelectionFollowsFocusProperty { get; }
NavigationViewShoulderNavigationEnabled ShoulderNavigationEnabled { get; set; }
public static DependencyProperty ShoulderNavigationEnabledProperty { get; }
NavigationViewTemplateSettings TemplateSettings { get; }
public static DependencyProperty TemplateSettingsProperty { get; }
public class NavigationViewItem : NavigationViewItemBase {
bool SelectsOnInvoked { get; set; }
public static DependencyProperty SelectsOnInvokedProperty { get; }
public sealed class NavigationViewItemInvokedEventArgs {
NavigationViewItemBase InvokedItemContainer { get; }
NavigationTransitionInfo RecommendedNavigationTransitionInfo { get; }
public enum NavigationViewOverflowLabelMode
public enum NavigationViewPaneDisplayMode
public sealed class NavigationViewSelectionChangedEventArgs {
NavigationTransitionInfo RecommendedNavigationTransitionInfo { get; }
NavigationViewItemBase SelectedItemContainer { get; }
public enum NavigationViewSelectionFollowsFocus
public enum NavigationViewShoulderNavigationEnabled
public class NavigationViewTemplateSettings : DependencyObject
public class Panel : FrameworkElement {
BrushTransition BackgroundTransition { get; set; }
public sealed class PasswordBox : Control {
bool CanPasteClipboardContent { get; }
public static DependencyProperty CanPasteClipboardContentProperty { get; }
object Description { get; set; }
public static DependencyProperty DescriptionProperty { get; }
FlyoutBase SelectionFlyout { get; set; }
public static DependencyProperty SelectionFlyoutProperty { get; }
void PasteFromClipboard();
public class RelativePanel : Panel {
BackgroundSizing BackgroundSizing { get; set; }
public static DependencyProperty BackgroundSizingProperty { get; }
public class RichEditBox : Control {
object Description { get; set; }
public static DependencyProperty DescriptionProperty { get; }
FlyoutBase ProofingMenuFlyout { get; }
public static DependencyProperty ProofingMenuFlyoutProperty { get; }
FlyoutBase SelectionFlyout { get; set; }
public static DependencyProperty SelectionFlyoutProperty { get; }
RichEditTextDocument TextDocument { get; }
event TypedEventHandler SelectionChanging;
public sealed class RichEditBoxSelectionChangingEventArgs
public sealed class RichTextBlock : FrameworkElement {
FlyoutBase SelectionFlyout { get; set; }
public static DependencyProperty SelectionFlyoutProperty { get; }
void CopySelectionToClipboard();
public sealed class ScrollContentPresenter : ContentPresenter {
bool CanContentRenderOutsideBounds { get; set; }
public static DependencyProperty CanContentRenderOutsideBoundsProperty { get; }
bool SizesContentToTemplatedParent { get; set; }
public static DependencyProperty SizesContentToTemplatedParentProperty { get; }
public sealed class ScrollViewer : ContentControl, IScrollAnchorProvider {
bool CanContentRenderOutsideBounds { get; set; }
public static DependencyProperty CanContentRenderOutsideBoundsProperty { get; }
UIElement CurrentAnchor { get; }
double HorizontalAnchorRatio { get; set; }
public static DependencyProperty HorizontalAnchorRatioProperty { get; }
bool ReduceViewportForCoreInputViewOcclusions { get; set; }
public static DependencyProperty ReduceViewportForCoreInputViewOcclusionsProperty { get; }
double VerticalAnchorRatio { get; set; }
public static DependencyProperty VerticalAnchorRatioProperty { get; }
event TypedEventHandler AnchorRequested;
public static bool GetCanContentRenderOutsideBounds(DependencyObject element);
void RegisterAnchorCandidate(UIElement element);
public static void SetCanContentRenderOutsideBounds(DependencyObject element, bool canContentRenderOutsideBounds);
void UnregisterAnchorCandidate(UIElement element);
public class SplitButton : ContentControl
public class SplitButtonAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider, IInvokeProvider
public sealed class SplitButtonClickEventArgs
public class StackPanel : Panel, IInsertionPanel, IScrollSnapPointsInfo {
BackgroundSizing BackgroundSizing { get; set; }
public static DependencyProperty BackgroundSizingProperty { get; }
public sealed class TextBlock : FrameworkElement {
FlyoutBase SelectionFlyout { get; set; }
public static DependencyProperty SelectionFlyoutProperty { get; }
void CopySelectionToClipboard();
public class TextBox : Control {
bool CanPasteClipboardContent { get; }
public static DependencyProperty CanPasteClipboardContentProperty { get; }
bool CanRedo { get; }
public static DependencyProperty CanRedoProperty { get; }
bool CanUndo { get; }
public static DependencyProperty CanUndoProperty { get; }
object Description { get; set; }
public static DependencyProperty DescriptionProperty { get; }
FlyoutBase ProofingMenuFlyout { get; }
public static DependencyProperty ProofingMenuFlyoutProperty { get; }
FlyoutBase SelectionFlyout { get; set; }
public static DependencyProperty SelectionFlyoutProperty { get; }
event TypedEventHandler SelectionChanging;
void ClearUndoRedoHistory();
void CopySelectionToClipboard();
void CutSelectionToClipboard();
void PasteFromClipboard();
void Redo();
void Undo();
public sealed class TextBoxSelectionChangingEventArgs
public class TextCommandBarFlyout : CommandBarFlyout
public class TimePicker : Control {
IReference SelectedTime { get; set; }
public static DependencyProperty SelectedTimeProperty { get; }
event TypedEventHandler SelectedTimeChanged;
public sealed class TimePickerSelectedValueChangedEventArgs
public class ToggleSplitButton : SplitButton
public class ToggleSplitButtonAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider, IToggleProvider
public sealed class ToggleSplitButtonIsCheckedChangedEventArgs
public class ToolTip : ContentControl {
IReference PlacementRect { get; set; }
public static DependencyProperty PlacementRectProperty { get; }
public class TreeView : Control {
bool CanDragItems { get; set; }
public static DependencyProperty CanDragItemsProperty { get; }
bool CanReorderItems { get; set; }
public static DependencyProperty CanReorderItemsProperty { get; }
Style ItemContainerStyle { get; set; }
public static DependencyProperty ItemContainerStyleProperty { get; }
StyleSelector ItemContainerStyleSelector { get; set; }
public static DependencyProperty ItemContainerStyleSelectorProperty { get; }
TransitionCollection ItemContainerTransitions { get; set; }
public static DependencyProperty ItemContainerTransitionsProperty { get; }
object ItemsSource { get; set; }
public static DependencyProperty ItemsSourceProperty { get; }
DataTemplate ItemTemplate { get; set; }
public static DependencyProperty ItemTemplateProperty { get; }
DataTemplateSelector ItemTemplateSelector { get; set; }
public static DependencyProperty ItemTemplateSelectorProperty { get; }
event TypedEventHandler DragItemsCompleted;
event TypedEventHandler DragItemsStarting;
DependencyObject ContainerFromItem(object item);
DependencyObject ContainerFromNode(TreeViewNode node);
object ItemFromContainer(DependencyObject container);
TreeViewNode NodeFromContainer(DependencyObject container);
public sealed class TreeViewCollapsedEventArgs {
object Item { get; }
public sealed class TreeViewDragItemsCompletedEventArgs
public sealed class TreeViewDragItemsStartingEventArgs
public sealed class TreeViewExpandingEventArgs {
object Item { get; }
public class TreeViewItem : ListViewItem {
bool HasUnrealizedChildren { get; set; }
public static DependencyProperty HasUnrealizedChildrenProperty { get; }
object ItemsSource { get; set; }
public static DependencyProperty ItemsSourceProperty { get; }
public class TwoPaneView : Control
public enum TwoPaneViewMode
public enum TwoPaneViewPriority
public enum TwoPaneViewTallModeConfiguration
public enum TwoPaneViewWideModeConfiguration
public sealed class WebView : FrameworkElement {
event TypedEventHandler WebResourceRequested;
public sealed class WebViewWebResourceRequestedEventArgs
namespace Windows.UI.Xaml.Controls.Maps {
public enum MapTileAnimationState
public sealed class MapTileBitmapRequestedEventArgs {
int FrameIndex { get; }
public class MapTileSource : DependencyObject {
MapTileAnimationState AnimationState { get; }
public static DependencyProperty AnimationStateProperty { get; }
bool AutoPlay { get; set; }
public static DependencyProperty AutoPlayProperty { get; }
int FrameCount { get; set; }
public static DependencyProperty FrameCountProperty { get; }
TimeSpan FrameDuration { get; set; }
public static DependencyProperty FrameDurationProperty { get; }
void Pause();
void Play();
void Stop();
public sealed class MapTileUriRequestedEventArgs {
int FrameIndex { get; }
namespace Windows.UI.Xaml.Controls.Primitives {
public class CommandBarFlyoutCommandBar : CommandBar
public sealed class CommandBarFlyoutCommandBarTemplateSettings : DependencyObject
public class FlyoutBase : DependencyObject {
bool AreOpenCloseAnimationsEnabled { get; set; }
public static DependencyProperty AreOpenCloseAnimationsEnabledProperty { get; }
bool InputDevicePrefersPrimaryCommands { get; }
public static DependencyProperty InputDevicePrefersPrimaryCommandsProperty { get; }
bool IsOpen { get; }
public static DependencyProperty IsOpenProperty { get; }
FlyoutShowMode ShowMode { get; set; }
public static DependencyProperty ShowModeProperty { get; }
public static DependencyProperty TargetProperty { get; }
void ShowAt(DependencyObject placementTarget, FlyoutShowOptions showOptions);
public enum FlyoutPlacementMode {
Auto = 13,
BottomEdgeAlignedLeft = 7,
BottomEdgeAlignedRight = 8,
LeftEdgeAlignedBottom = 10,
LeftEdgeAlignedTop = 9,
RightEdgeAlignedBottom = 12,
RightEdgeAlignedTop = 11,
TopEdgeAlignedLeft = 5,
TopEdgeAlignedRight = 6,
public enum FlyoutShowMode
public class FlyoutShowOptions
public class NavigationViewItemPresenter : ContentControl
namespace Windows.UI.Xaml.Core.Direct {
public interface IXamlDirectObject
public sealed class XamlDirect
public struct XamlDirectContract
public enum XamlEventIndex
public enum XamlPropertyIndex
public enum XamlTypeIndex
namespace Windows.UI.Xaml.Hosting {
public class DesktopWindowXamlSource : IClosable
public sealed class DesktopWindowXamlSourceGotFocusEventArgs
public sealed class DesktopWindowXamlSourceTakeFocusRequestedEventArgs
public sealed class WindowsXamlManager : IClosable
public enum XamlSourceFocusNavigationReason
public sealed class XamlSourceFocusNavigationRequest
public sealed class XamlSourceFocusNavigationResult
namespace Windows.UI.Xaml.Input {
public sealed class CanExecuteRequestedEventArgs
public sealed class ExecuteRequestedEventArgs
public sealed class FocusManager {
public static event EventHandler GettingFocus;
public static event EventHandler GotFocus;
public static event EventHandler LosingFocus;
public static event EventHandler LostFocus;
public sealed class FocusManagerGotFocusEventArgs
public sealed class FocusManagerLostFocusEventArgs
public sealed class GettingFocusEventArgs : RoutedEventArgs {
Guid CorrelationId { get; }
public sealed class LosingFocusEventArgs : RoutedEventArgs {
Guid CorrelationId { get; }
public class StandardUICommand : XamlUICommand
public enum StandardUICommandKind
public class XamlUICommand : DependencyObject, ICommand
namespace Windows.UI.Xaml.Markup {
public sealed class FullXamlMetadataProviderAttribute : Attribute
public interface IXamlBindScopeDiagnostics
public interface IXamlType2 : IXamlType
namespace Windows.UI.Xaml.Media {
public class Brush : DependencyObject, IAnimationObject {
void PopulatePropertyInfo(string propertyName, AnimationPropertyInfo propertyInfo);
virtual void PopulatePropertyInfoOverride(string propertyName, AnimationPropertyInfo animationPropertyInfo);
public class Shadow : DependencyObject
public class ThemeShadow : Shadow
namespace Windows.UI.Xaml.Media.Animation {
public class BasicConnectedAnimationConfiguration : ConnectedAnimationConfiguration
public sealed class ConnectedAnimation {
ConnectedAnimationConfiguration Configuration { get; set; }
public class ConnectedAnimationConfiguration
public class DirectConnectedAnimationConfiguration : ConnectedAnimationConfiguration
public class GravityConnectedAnimationConfiguration : ConnectedAnimationConfiguration
public enum SlideNavigationTransitionEffect
public sealed class SlideNavigationTransitionInfo : NavigationTransitionInfo {
SlideNavigationTransitionEffect Effect { get; set; }
public static DependencyProperty EffectProperty { get; }
namespace Windows.UI.Xaml.Navigation {
public class FrameNavigationOptions
namespace Windows.Web.UI {
public interface IWebViewControl2
public sealed class WebViewControlNewWindowRequestedEventArgs {
IWebViewControl NewWindow { get; set; }
Deferral GetDeferral();
public enum WebViewControlPermissionType {
ImmersiveView = 6,
namespace Windows.Web.UI.Interop {
public sealed class WebViewControl : IWebViewControl, IWebViewControl2 {
event TypedEventHandler GotFocus;
event TypedEventHandler LostFocus;
void AddInitializeScript(string script);


namespace Windows.Gaming.UI {
public sealed class GameMonitor
public enum GameMonitoringPermission

Windows 10 Tip: Try reading on a full screen for a distraction-free experience in Microsoft Edge – Windows Experience Blog

Want to focus on a new book, report or story? But having a hard time because of the many other things vying for your attention on your computer screen?
With the Windows 10 April 2018 Update, you can take books, PDFs and Reading view pages full-screen, for a distraction-free reading experience in Microsoft Edge.
To do this, click on the double-arrow icon in the reading bar, or in the More menu, or hit F11 on your keyboard.
Here’s how to do it:
Take your reading to a full screen for a distraction free experience.
If you like this, check out more Windows 10 Tips.

Windows 10 Tip: Windows Ink directly in textbox, new in the Windows 10 April 2018 Update – Windows Experience Blog

If you prefer to ink instead of type, you can now use your digital pen to write directly in text fields for a more natural experience, thanks to the Windows 10 April 2018 Update.Just tap a space, like a search box, and it expands to give you a comfortable area in which to write. You can even edit what you’ve written with simple, intuitive gestures.
Go to Settings > Devices > Pen & Windows Ink > select, “Write directly into text field” and then tap on a new text field to try the experience. This works with most Store apps, and also in the search field for the Store.
Here’s how to do it:
Steps to enabling writing directly in a text field.
Open a search box in an app such as Microsoft Store and it expands so you can write directly in it.
Touch-enabled device required; pen accessory may be sold separately. Tap to ink available in UWP and XAML fields. User must enable in pen settings.
If you like this, check out more Windows 10 Tips.

Windows 10 Tip: Get more out of reading online with Grammar Tools in Microsoft Edge – Windows Experience Blog

Reading online is convenient, but did you know it can also help you get more out of books and articles? Microsoft Edge has built-in learning tools that make it easier to read EPUB books and websites in Reading view: Grammar Tools.The Windows 10 April 2018 Update added Grammar Tools support that allow you to break words into syllables and highlight parts of speed, such as nouns, verbs and adjectives.
These tools can improve reading comprehension through increasing fluency for English language learners or readers of other languages, and they can also help build confidence for emerging readers learning to read at higher levels. Breaking words into syllables improves word recognition, while highlighting parts of speech supports reading instruction and can improve writing quality.
Click on the image below to see how to use Grammar Tools:
When you’re in Reading view, open Grammar Tools to break words into syllables and highlight parts of speed, such as nouns, verbs and adjectives.
Want to know what else you can do? Check out more Windows 10 Tips.

Chakra documentation is joining MDN web docs – Microsoft Edge Dev Blog

Last fall, along with other browser vendors and web platform stakeholders, the Edge platform (EdgeHTML) team adopted MDN web docs as our official web API reference library. In the process, we redirected over 7700 MSDN pages for HTML, CSS, SVG and DOM APIs to corresponding reference content on MDN and joined the community in helping maintain it, including making over 5000 edits to the browser compatibility tables to reflect the latest Edge API surfaceToday the Microsoft Edge JavaScript engine, Chakra, joins the community-wide effort to make MDN web docs the web’s one-stop, premiere development reference, starting by redirecting all 500+ pages of Microsoft’s JavaScript API reference from to their MDN counterparts and porting our legacy JS extensions reference for historical and servicing purposes.

We want to thank our community for enthusiastically embracing MDN web docs, and special kudos to everyone who helps to improve the docs, edit by edit. In the previous year alone, you helped the MDN web docs community grow monthly users by over 50%! Let’s keep documenting the web forward together.
– Erika Doyle Navara, MDN Product Advisory Board representative for Microsoft Edge

Find the perfect gift for dads and grads from Microsoft Store and our partners

June 7, 2018 9:00 am

By Annie Arnold / Microsoft Education Communications Lead






Today, we’re highlighting gift ideas to help you find the perfect gift for the dad or grad in your life. From Xbox One S to Surface devices, here are 16 awesome deals for the dad or grad in your life.

With Father’s Day just around the corner and graduation season in full force, you won’t want to miss these steep discounts coming to Microsoft Store and other partner retailers this month! If your Dad or recent grad is a gadget geek, mark your calendar so you don’t miss out.  

1. Save up to $200 on select Surface Book 2 today through 6/16 in the US/PR.

2. Save up to $400 on select gaming PCs today through 6/24 in the US/CA.

3. Save $200 on select Surface Pro i5 beginning 6/10-6/30 in the US/PR.

4. Save on select Xbox One S 1TB ($249) today through 6/23 in the US/PR.

5. Save up to $500 on select Windows 10 PCs today through 6/24 in the US/CA.

6. Save $100 on the Samsung HMD Odyssey Windows Mixed Reality headset today through 6/16 in the US/PR/CA.

7. Save up to 50% on select Belkin accessories and more today through 6/24 in the US/CA.

8. Save $20 on the JLab Audio Epic Sport Wireless Earbuds in the US/PR, and $25 in CA today through 6/17.

Microsoft gives parents peace of mind with new family features across devices – Windows Experience Blog

We live in a time of both great opportunity and great responsibility. Our children have access to more information, entertainment and more ways to connect than ever before, but with that comes plenty of new things that parents like you and I need to worry about and new ways to distract their attention. Today, we are excited to introduce new features that make it easier and safer for families to interact with technology and, each other, across devices and platforms.
Creating tools and features that empower both parents and kids has always been an important part of our work and is becoming increasingly vital, not only to us as a business, but to us as individuals – parents, aunts and uncles, siblings and friends. As a mother to a young and curious daughter, I deeply understand the need for tools to help balance the use of technology in the home as well as out of the home. It’s especially near and dear to me as leader of a team building experiences for mobile devices. We emphasize the idea of transparency as a guiding principle for these new experiences. Today, I am happy to share new features that will help create greater transparency between parent and child, as well as between Microsoft and parents in what to expect from our tools.

We’re bringing new features to the popular Microsoft Launcher app for Android with two new mobile experiences, currently in preview, that give parents more peace of mind for their family and a look at your child’s activity across their devices – Windows 10 PCs, Xbox One devices, and now their Android phone.
With Microsoft Launcher installed on your family’s Android devices and a Microsoft family group of accounts set up, parents can:
Stay up to date on kids’ whereabouts. At home and on the go, you can use Microsoft Launcher to get an update on your kids’ location and rest easier knowing they are safely where they should be. You can see your child’s (or children’s) last known location and time.
Be aware of which apps your kids are using. Check in on your kids’ app activity on their Android device, including which apps are accessed and time spent on each app. With Xbox One or a Windows 10 PC set up in your family portal, you can also view their activities on those devices through Microsoft Launcher.
Microsoft Launcher is the only launcher that gives parents this visibility across Android, Windows 10, and Xbox One devices. Children and parents always have the option to toggle features off and on at any time and, best of all, it’s free. If you have a Microsoft family group, you can install Microsoft Launcher on your family’s Android devices. If you don’t have a family group set up yet, it’s easy – here’s how.

With Microsoft Edge, the ability to allow or block websites has always existed on your PCs. Now, we are extending this feature to you and your family’s Android devices. If you have set up a Microsoft family group, any websites you have already tagged as allowed or blocked for your kid(s) will carry the same settings as they try to access websites in Microsoft Edge on their Android devices. The update will begin rolling out today.

We are also excited to announce MSN Kids, currently in preview, a curated news site created specifically for children in the elementary and middle school age group. We saw a need for a place for kids to learn about the world in a safe, trustworthy and fun environment. The site offers editorially curated, age-appropriate news and features from partner publishers such as Time for Kids, Popular Science, Sports Illustrated for Kids, National Geographic, and USA TODAY.
MSN Kids brings curated, kid-friendly news to the web
Content is kid-friendly and helps children find things of interest to stay engaged, learn, and have fun – with no sponsored content or advertising. Kids can learn about animals, the world around them, kids like them doing interesting things around the globe and more. When using Microsoft Edge, kids can also use pen and read aloud to engage with puzzles or assist with reading articles. Check out the preview today at

These new experiences are the next step in a long history of creating products, features, and settings with families in mind, spanning gaming to mobile to PC and the web.
Family safety settings in Windows 10 and Xbox One:  With families today owning more personal devices than ever, including kids at increasingly younger ages, we’ve invested in family settings that work across devices and platforms. A core set of family safety settings – including the ability to block mature content and apps, set screen time limits, and review kids’ purchase requests – have long been available for Windows 10 PCs and Xbox One devices. These settings help parents keep kids safer, while also fostering independence and letting kids do homework, research, and be creative, using technology as a powerful learning tool.
Safer online spending with Ask a parent:  One especially useful setting, called Ask a parent, lets parents avoid surprise spending on Xbox or the Microsoft Store by receiving notifications when kids want to make a purchase. Parents can decide whether to approve based on the maturity level, cost, and whether it fits within screen time allowed. From the kids’ perspective, it’s a good way to let Mom or Dad know what cool new game they want. From the parents’ perspective, it’s a good way to help kids manage temptations (such as in-app purchases) and make good choices.
Shared family notebook in OneNote: Earlier this month we released the new family notebook in OneNote. We know families are busier than ever and with a family notebook your whole family can stay in sync and organized – from shopping lists to vacation planning, the whole family can share, edit and access information in one place.
These are just some of the many great features across our devices and services that empower families with peace of mind, tools to learn, grow and, of course, have fun. More information can be found at this page. Please download Microsoft Launcher and Microsoft Edge for Android and give the new features a try. We look forward to hearing your feedback so we can empower you with the best tools to create the safest, most productive and fun experiences for our families.

Microsoft gives parents peace of mind with new family features across devices
Tweet This

New features for extensions in the Windows 10 April 2018 Update – Microsoft Edge Dev Blog

The Windows 10 April 2018 Update includes several incremental improvements to API support, functionality, and end-user discoverability for the extensions platform in Microsoft Edge. In this post, we’ll walk through the biggest improvements, and how you can get started enhancing your extensions with new features.Extensions can now be enabled for InPrivate browsing
In previous releases, extensions could not be enabled during an inPrivate browsing session. Beginning with this release, users can now choose to allow extensions to run during inPrivate browsing on a case-by-case basis – either when the extension is initially installed (by selecting the “Allow for inPrivate browsing” checkbox), or at any later time by visiting the Settings page for a given extension.
When running inPrivate, extensions can run in either split or span mode as specified by the WebExtensions API. In span mode (the default), the extension spans both inPrivate and non-private windows; windows and tabs from an inPrivate instance are indicated to the extension with an incognito property. In split mode, a separate instance of the extension is created for inPrivate and normal browsing, and the two copies are isolated (the inPrivate copy cannot see non-private windows, and the non-private copy cannot see inPrivate windows).
Extensions are now available when browsing inPrivate
Extensions in span mode can be debugged as with a normal extension. Extensions in split mode can be debugged separately for each instance, as the background script is separate for normal and InPrivate sessions.
The background script is separate for normal and inPrivate sessions.
Introducing the Notifications API for extensions
Extensions can now display interactive notifications , including basic messages, progress indicators, lists, and more. Developers can customize the appearance of these notifications by configuring the icon, text, buttons, and button icons.
Examples of progress, list, image and basic notifications
In the sample below, we’ll demonstrate the process to create a basic notification. The first step is to define the notification options:

Next, we’ll add event listeners for various user interactions:

The notification can now be invoked:

Notifications sent from an extension use the standard Windows notification service, appearing in Action Center until an action is taken. Users have full control over notifications, and can choose to suppress notifications originating from a specific extension using either the extension’s menu in Microsoft Edge or by acting on an individual notification in the Windows Action Center.
Users can suppress notifications for an extension from the Action Center or the extension settings
Extension developers can determine if notifications are enabled or disabled using the getPermissionLevel() method:

The event onPermissionLevelChanged will be raised if the user changes the notification permission:

Support for Tabs.reload()
Microsoft Edge extensions now support the tabs.reload() method in the tabs API class, allowing extensions to directly reload a specific tab using this method.

We are continuing to make enhancements to extensions platform for future releases. You can see a snapshot of our current roadmap on Microsoft Docs at Microsoft Edge Extension API roadmap. To get started building your extension for Microsoft Edge, check out Getting started with extensions.
We look forward to your feedback on these improvements! You can vote on the most important features for your extension development on the Microsoft Edge Developer UserVoice, or share your feedback in the comments below.
– Balaje Krishnan, Senior Program Manager, Microsoft Edge
Updated May 24, 2018 10:29 am

Windows 10 Tip: A guide to the basic tools in Paint 3D

Paint 3D is a built-in creative application that comes free with Windows 10*.  It is designed to be simple yet powerful by allowing you to create professional or fun creative projects by easily combining 2D and 3D tools. The best part is that you don’t need any design experience – Paint 3D can be used by anyone.  Its approachable interface makes it easy to customize existing 3D models from our built-in 3D library or create 3D designs from scratch.
Getting started: Paint 3D’s basic navigation

Brushes: Expand your artistic abilities with unique pens & brushes that mimic real materials without the mess. Try transparent watercolor that beautifully washes the canvas or oil painting so real that you can see the paint smudging.  These artistic brushes work both on both the canvas and on 3D models with professional effects such as polished metal and matte to help personalize your designs.

2D Shapes: It is easy to draw perfect shapes with our collection of 2D shapes and the line and curve tool. Use the control circles to manipulate the curvature to your desired angle.  You can also click Make 3D to turn the shape into a layer with additional rotation options.

Give it a go! Click here to view the circuit board model on  Bring it into Paint 3D and use 2D shapes to add the correct symbols to the circuit diagram. Then use the line and curve tool to fill in the correct waveform patterns. Watch this video for tips on 2D Shapes.
3D Shapes: There are many ways to get started in creating in 3D. Use pre-made shapes to jump start building a new model or use the 3D doodle tool to instant turn your 2D sketches in 3D models.  Simply trace a design from a photo or draw one free hand and watch as it instantly pop into a 3D model.  The sharp edge 3D doodle creates sharp lines, perfect for drawing a star.  The soft edge 3D doodle creates a soft curve, perfect for drawing a cloud.

Click here to view the chair concept image on  Bring it into Paint 3D and use both 3D doodle tools to trace around the image and pop it out into 3D. Watch this video for tips on the 3D Doodle tool.
Stickers: This is a unique and easy way to add texture to your creations. Use this tool to experiment with materials such as wood or marble or upload your own photo to create a custom texture sticker.  It will instantly wrap around 3D objects–no prior 3D knowledge needed!  You can also adjust the opacity of the sticker.

Text: Add words using our 2D & 3D text options. 2D will anchor the text to the canvas while 3D text will allow you to move it around the canvas and rotate to different directions.
Effects: Create unique moods such as calming Mist or mysterious Night by changing the environment and lighting in your 3D scenes. You can even move the sun around a light wheel to change the direction of the lighting.

Canvas: This digital canvas mimics a painter’s canvas. This tab allows you to resize and control the dimensions, including turning off the 2D canvas so you can freely design your 3D model.
Magic Select: Easy to use tool that allows you to select the part of the image that you want to cut out and remove it from the background. The tool instantly and almost magically pops out your selection onto another layer and intelligently auto-fills the background to hide any gaps.

3D library**: Browse our huge catalog of thousands of free 3D models for you to edit. Choose from our pre-curated collections to get started quickly or search for your desired model in the search tool bar.  With a tap, you can instantly import the 3D model into your project and begin recoloring and customizing right away.
History Slider: You can undo and rewind all your actions, it’s like an unlimited undo button! The history slider records every change in the scene and allows you to scroll back through time.  You can even create a video of your design process to share with friends by click on the start recording button.
3D View mode: This allows you to move around and see your content from any angle. There are also controls to help you zoom in and out of the canvas with the ability to enter a precise zoom amount.

Click here to view the shark scene on in into Paint 3D and use 3D view mode to position the fins correctly. Then use the 3D doodle tool to add and position a dorsal fin.
Watch this video for tips on using 3D view mode.
Mixed Reality: This takes your 3D model from Paint 3D and launches it into the Mixed Reality Viewer application so you can visualize the 3D model in a real world context. You can snap a photo or record a short video of the 3D object interacting with your world to share with friends.
Paint 3D makes it easy to unlock your creativity and bring your ideas to life.  To check out these features for yourself, you can get started by opening the Paint 3D app. If you are new to Paint 3D, check out our video tutorials on Paint 3D here.
* To access all the latest Paint 3D features, you will need to update to the latest Windows 10 April 2018 Update.  To learn how to get the Windows 10 April 2018 Update, check out this blog post. 
**3D Library is available in select markets.  Check out the online library here. 

Windows 10 Tip: Organize your busy lives with a family notebook in OneNote

Grocery lists. Vacation planning. Shared notes. Families share information every day, and often, it’s challenging to capture it all and keep it up to date. That’s where a family notebook comes in.
Share to-do lists, recipes, vacation plans, and more
Once your notebook is created, it will be automatically shared with your Microsoft family. Whatever you choose to add to your family notebook, it will be in one place that everyone in your family can access.
We’ve started you off with some examples for Household management, Food, Vacations, and more.

Add new sections for your family’s favorites
Track your favorite TV shows, home projects, or any other information you want to share – in one convenient place. Here are some more great ideas for your family notebook:
Neighbor info
Restaurant and take-out menus
Family projects
And more…whatever your family wants to share!
Getting started is easy
If you have Microsoft accounts set up for everyone in your family, you can create your family notebook now. If you don’t yet, go here to set one up – it’s quick, and once you do, you’ll have access to other great stuff like settings for keeping kids safe online, setting screen time limits, and more. To learn more, head over here!