Interactions avec le stylet et Windows Ink dans les applications Windows
Stylet Surface (disponible à l’achat dans la Boutique Microsoft).
Vue d’ensemble
Optimisez votre application Windows pour l’entrée au stylet afin de fournir à vos utilisateurs la fonctionnalité standard de l’appareil pointeur et la meilleure expérience Windows Ink.
Notes
Cette rubrique est dédiée à la plateforme Windows Ink. Pour en savoir plus sur la gestion des entrées au pointeur (similaires aux fonctionnalités tactiles, de la souris et du pavé tactile), consultez Gérer les entrées du pointeur.
Utilisation de l’entrée manuscrite dans votre application Windows
Utiliser le stylet et l’entrée manuscrite Windows pour créer des applications d’entreprise plus conviviales
La plateforme Windows Ink, associée à un stylet, permet de créer des notes manuscrites, des dessins et des annotations plus naturellement. La plateforme prend en charge la capture d’entrée du numériseur sous forme de données d’entrée manuscrite, la génération et la gestion de données d’entrée manuscrite, la restitution de ces données sous forme de traits et la conversion de l’encre en texte via la reconnaissance d’écriture manuscrite.
En plus de capturer la position et les mouvements de base du stylet lorsque l’utilisateur écrit ou dessine, votre application peut également effectuer le suivi des niveaux de pression variables utilisés pour un trait et en effectuer le suivi. Ces informations, ainsi que les paramètres relatifs à la forme de la pointe, à sa taille et à sa rotation, à la couleur de l’encre et à l’utilisation (entrée manuscrite normale, effacement, surlignage et sélection), vous permettent de proposer des expériences utilisateur ressemblant étroitement à l’écriture ou au dessin sur papier à l’aide d’un stylo, d’un crayon ou d’un pinceau.
Notes
Votre application prend également en charge l’entrée manuscrite à partir d’autres appareils de pointage, comme les numériseurs tactiles et les souris.
La plateforme d’entrée manuscrite est très flexible. Elle est conçue pour prendre en charge différents niveaux de fonctionnalité, en fonction de vos besoins.
Pour obtenir des recommandations en matière d’expérience utilisateur avec Windows Ink, consultez Contrôles pour l’entrée manuscrite.
Composants de la plateforme Windows Ink
| Composant | Description |
|---|---|
| InkCanvas | Un contrôle de plateforme d’interface utilisateur XAML, qui reçoit et affiche par défaut toutes les entrées à partir d’un stylet comme un trait d’encre ou un trait d’effacement. Pour plus d’informations sur l’utilisation de l’élément InkCanvas, consultez Reconnaître les traits d’encre Windows en tant que texte et Stocker et récupérer les données de traits Windows Ink. |
| InkPresenter | Objet code-behind, instancié avec un contrôle InkCanvas (exposé via la propriété InkCanvas.InkPresenter ). Cet objet fournit toutes les fonctionnalités d’entrée manuscrite par défaut exposées par l’élément InkCanvas, ainsi qu’un ensemble complet d’API pour plus de personnalisation. Pour plus d’informations sur l’utilisation de l’élément InkPresenter, consultez Reconnaître les traits d’encre Windows en tant que texte et Stocker et récupérer les données de traits Windows Ink. |
| InkToolbar | Contrôle de plateforme d’interface utilisateur XAML contenant une collection personnalisable et extensible de boutons qui activent des fonctionnalités liées à l’entrée manuscrite dans un InkCanvas associé. Pour plus d’informations sur l’utilisation d’InkToolbar, consultez Ajouter un InkToolbar à une application manuscrite d’application Windows. |
| IInkD2DRenderer | Active le rendu des traits d’encre dans le contexte d’appareil Direct2D désigné d’une application Windows universelle, au lieu du contrôle InkCanvas par défaut. Cela offre une personnalisation totale de l’expérience d’entrée manuscrite. Pour plus d’informations, consultez l’exemple d’entrée manuscrite complexe. |
Entrée manuscrite de base avec InkCanvas
Pour ajouter des fonctionnalités manuscrites de base, placez simplement un contrôle de plateforme UWP InkCanvas sur la page appropriée de votre application.
Par défaut, l’élément InkCanvas prend en charge l’entrée manuscrite uniquement à partir d’un stylet. L’entrée est restituée sous la forme d’un trait d’encre à l’aide des paramètres par défaut pour la couleur et l’épaisseur (un stylo à bille noir avec une épaisseur de 2 pixels), ou traitée sous forme d’un effaceur de trait (lorsque l’entrée manuscrite est effectuée à partir d’une pointe d’effaceur ou que la pointe du stylet est modifiée à l’aide d’un bouton d’effacement).
Notes
Si une pointe d’effaceur ou le bouton n’est pas présent, l’élément InkCanvas peut être configuré pour traiter les entrées à partir de la pointe du stylet comme un trait d’effacement.
Dans cet exemple, un inkCanvas superpose une image d’arrière-plan.
Notes
Un InkCanvas a par défaut les propriétés Height et Width de zéro, sauf s’il s’agit de l’enfant d’un élément qui dimensionne automatiquement ses éléments enfants, tels que les contrôles StackPanel ou Grid .
<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<StackPanel x:Name="HeaderPanel" Orientation="Horizontal" Grid.Row="0">
<TextBlock x:Name="Header"
Text="Basic ink sample"
Style="{ThemeResource HeaderTextBlockStyle}"
Margin="10,0,0,0" />
</StackPanel>
<Grid Grid.Row="1">
<Image Source="Assets\StoreLogo.png" />
<InkCanvas x:Name="inkCanvas" />
</Grid>
</Grid>
Cette série d’images montre comment une entrée manuscrite de stylet est restituée par ce contrôle InkCanvas.
 |
 |
 |
|---|---|---|
| InkCanvas vide avec une image d’arrière-plan. | InkCanvas avec des traits d’encre. | InkCanvas avec un trait effacé (notez comment fonctionne l’effacement sur un trait complet et non seulement sur une partie). |
La fonctionnalité d’entrée manuscrite prise en charge par le contrôle InkCanvas est proposée par un objet code-behind appelé InkPresenter.
Pour l’entrée manuscrite de base, vous n’avez pas à vous soucier d’InkPresenter. Toutefois, pour personnaliser et configurer le comportement de l’entrée manuscrite sur l’élément InkCanvas, vous devez accéder à son objet InkPresenter correspondant.
Personnalisation de base avec InkPresenter
Un objet InkPresenter est instancié avec chaque contrôle InkCanvas.
Notes
L’élément InkPresenter ne peut pas être instancié directement. Au lieu de cela, elle est accessible via la propriété InkPresenter de l’objet InkCanvas.
En plus de fournir tous les comportements d’entrée manuscrite par défaut de son contrôle InkCanvas correspondant, InkPresenter fournit un ensemble complet d’API pour une personnalisation supplémentaire du trait et une gestion plus fine de l’entrée du stylet (standard et modifié). Cela inclut les propriétés de trait, les types de périphériques d’entrée pris en charge et si l’entrée est traitée par l’objet ou transmise à l’application pour traitement.
Notes
L’entrée manuscrite standard (à partir d’une pointe de stylet ou d’un bouton de gomme) n’est pas modifiée avec une affordance matérielle secondaire, telle qu’un bouton de canon de stylet, un bouton droit de la souris ou un mécanisme similaire.
Par défaut, l’entrée manuscrite est prise en charge uniquement pour l’entrée de stylet. Ici, nous configurons InkPresenter pour interpréter les données d’entrée du stylet et de la souris en tant que traits d’encre. Nous définissons également des attributs de trait d’encre initiaux utilisés pour restituer les traits dans l’élément InkCanvas.
Pour activer l’entrée manuscrite tactile et la souris, définissez la propriété InputDeviceTypesd’InkPresenter sur la combinaison de valeurs CoreInputDeviceTypes souhaitées.
public MainPage()
{
this.InitializeComponent();
// Set supported inking device types.
inkCanvas.InkPresenter.InputDeviceTypes =
Windows.UI.Core.CoreInputDeviceTypes.Mouse |
Windows.UI.Core.CoreInputDeviceTypes.Pen;
// Set initial ink stroke attributes.
InkDrawingAttributes drawingAttributes = new InkDrawingAttributes();
drawingAttributes.Color = Windows.UI.Colors.Black;
drawingAttributes.IgnorePressure = false;
drawingAttributes.FitToCurve = true;
inkCanvas.InkPresenter.UpdateDefaultDrawingAttributes(drawingAttributes);
}
Les attributs de traits d’encre peuvent être définis de manière dynamique pour s’adapter aux préférences de l’utilisateur ou aux exigences de l’application.
Ici, nous laissons un utilisateur choisir parmi une liste de couleurs d’encre.
<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<StackPanel x:Name="HeaderPanel" Orientation="Horizontal" Grid.Row="0">
<TextBlock x:Name="Header"
Text="Basic ink customization sample"
VerticalAlignment="Center"
Style="{ThemeResource HeaderTextBlockStyle}"
Margin="10,0,0,0" />
<TextBlock Text="Color:"
Style="{StaticResource SubheaderTextBlockStyle}"
VerticalAlignment="Center"
Margin="50,0,10,0"/>
<ComboBox x:Name="PenColor"
VerticalAlignment="Center"
SelectedIndex="0"
SelectionChanged="OnPenColorChanged">
<ComboBoxItem Content="Black"/>
<ComboBoxItem Content="Red"/>
</ComboBox>
</StackPanel>
<Grid Grid.Row="1">
<Image Source="Assets\StoreLogo.png" />
<InkCanvas x:Name="inkCanvas" />
</Grid>
</Grid>
Nous traitons ensuite les modifications de manière à tenir compte de la couleur sélectionnée et actualisons les attributs de traits d’encre en conséquence.
// Update ink stroke color for new strokes.
private void OnPenColorChanged(object sender, SelectionChangedEventArgs e)
{
if (inkCanvas != null)
{
InkDrawingAttributes drawingAttributes =
inkCanvas.InkPresenter.CopyDefaultDrawingAttributes();
string value = ((ComboBoxItem)PenColor.SelectedItem).Content.ToString();
switch (value)
{
case "Black":
drawingAttributes.Color = Windows.UI.Colors.Black;
break;
case "Red":
drawingAttributes.Color = Windows.UI.Colors.Red;
break;
default:
drawingAttributes.Color = Windows.UI.Colors.Black;
break;
};
inkCanvas.InkPresenter.UpdateDefaultDrawingAttributes(drawingAttributes);
}
}
Ces images montrent comment l’élément InkPresenter traite et personnalise l’entrée de stylet.
InkCanvas avec des traits d’encre noire par défaut.
InkCanvas avec les traits d’encre rouges sélectionnés par l’utilisateur.
Pour exploiter des fonctionnalités dépassant l’entrée manuscrite et l’effacement, telles que la sélection de trait, votre application doit identifier une entrée spécifique afin que l’élément InkPresenter la transmette directement non traitée afin d’être gérée par votre application.
Entrée directe pour traitement avancé
Par défaut, InkPresenter traite toutes les entrées sous la forme d’un trait d’encre ou d’un trait d’effacement, y compris l’entrée modifiée par une affordance matérielle secondaire telle qu’un bouton de stylet, un bouton droit de la souris ou similaire. Toutefois, les utilisateurs s’attendent généralement à des fonctionnalités supplémentaires ou à un comportement modifié avec ces affordances secondaires.
Dans certains cas, vous devrez peut-être également exposer des fonctionnalités supplémentaires pour les stylets sans affordances secondaires (fonctionnalité qui n’est généralement pas associée à l’extrémité du stylet), d’autres types de périphériques d’entrée ou un type de comportement modifié en fonction d’une sélection d’utilisateur dans l’interface utilisateur de votre application.
Pour prendre en charge cela, InkPresenter peut être configuré pour laisser une entrée spécifique non traitées. Cette entrée non traitée est ensuite directement transmise à votre application pour traitement.
Exemple : utiliser une entrée non traitées pour implémenter la sélection de traits
La plateforme Windows Ink ne fournit pas de prise en charge intégrée pour les actions qui nécessitent une entrée modifiée, comme la sélection de traits. Pour prendre en charge de telles fonctionnalités, vous devez fournir une solution personnalisée dans vos applications.
L’exemple de code suivant (tout le code se trouve dans les fichiers MainPage.xaml et MainPage.xaml.cs) explique comment activer la sélection du trait lorsque l’entrée est modifiée avec un bouton de stylet (ou un bouton droit de la souris).
Tout d’abord, nous configurons l’interface utilisateur dans MainPage.xaml.
Ici, nous ajoutons un canevas (sous InkCanvas) pour dessiner le trait de sélection. Une couche distincte permet de dessiner le trait de sélection sans modifier l’élément InkCanvas ni son contenu.
<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"> <Grid.RowDefinitions> <RowDefinition Height="Auto"/> <RowDefinition Height="*"/> </Grid.RowDefinitions> <StackPanel x:Name="HeaderPanel" Orientation="Horizontal" Grid.Row="0"> <TextBlock x:Name="Header" Text="Advanced ink customization sample" VerticalAlignment="Center" Style="{ThemeResource HeaderTextBlockStyle}" Margin="10,0,0,0" /> </StackPanel> <Grid Grid.Row="1"> <!-- Canvas for displaying selection UI. --> <Canvas x:Name="selectionCanvas"/> <!-- Inking area --> <InkCanvas x:Name="inkCanvas"/> </Grid> </Grid>Dans MainPage.xaml.cs, nous déclarons quelques variables globales pour conserver des références à des aspects de l’interface utilisateur de sélection. Plus précisément, le trait du lasso de sélection et le rectangle englobant qui met en surbrillance les traits sélectionnés.
// Stroke selection tool. private Polyline lasso; // Stroke selection area. private Rect boundingRect;Ensuite, nous configurons InkPresenter pour interpréter les données d’entrée du stylet et de la souris en tant que traits d’encre, et nous définissons certains attributs de trait d’encre initiaux utilisés pour le rendu des traits sur InkCanvas.
Plus important encore, nous utilisons la propriété InputProcessingConfiguration de l’élément InkPresenter pour indiquer que toute entrée modifiée doit être traitée par l’application. La modification d’une entrée est spécifiée en attribuant à InputProcessingConfiguration.RightDragAction la valeur InkInputRightDragAction.LeaveUnprocessed. Lorsque cette valeur est définie, inkPresenter passe à la classe InkUnprocessedInput , un ensemble d’événements de pointeur que vous devez gérer.
Nous affectons des écouteurs pour les événements PointerPressed, PointerMoved et PointerReleased non traités transmis par InkPresenter. Toutes les fonctionnalités de sélection sont implémentées dans les gestionnaires de ces événements.
Enfin, nous affectons des écouteurs pour les événements StrokeStarted et StrokesErased de InkPresenter. Nous utilisons les gestionnaires de ces événements pour nettoyer l’interface utilisateur de sélection si un nouveau trait est commencé ou un trait existant effacé.
public MainPage() { this.InitializeComponent(); // Set supported inking device types. inkCanvas.InkPresenter.InputDeviceTypes = Windows.UI.Core.CoreInputDeviceTypes.Mouse | Windows.UI.Core.CoreInputDeviceTypes.Pen; // Set initial ink stroke attributes. InkDrawingAttributes drawingAttributes = new InkDrawingAttributes(); drawingAttributes.Color = Windows.UI.Colors.Black; drawingAttributes.IgnorePressure = false; drawingAttributes.FitToCurve = true; inkCanvas.InkPresenter.UpdateDefaultDrawingAttributes(drawingAttributes); // By default, the InkPresenter processes input modified by // a secondary affordance (pen barrel button, right mouse // button, or similar) as ink. // To pass through modified input to the app for custom processing // on the app UI thread instead of the background ink thread, set // InputProcessingConfiguration.RightDragAction to LeaveUnprocessed. inkCanvas.InkPresenter.InputProcessingConfiguration.RightDragAction = InkInputRightDragAction.LeaveUnprocessed; // Listen for unprocessed pointer events from modified input. // The input is used to provide selection functionality. inkCanvas.InkPresenter.UnprocessedInput.PointerPressed += UnprocessedInput_PointerPressed; inkCanvas.InkPresenter.UnprocessedInput.PointerMoved += UnprocessedInput_PointerMoved; inkCanvas.InkPresenter.UnprocessedInput.PointerReleased += UnprocessedInput_PointerReleased; // Listen for new ink or erase strokes to clean up selection UI. inkCanvas.InkPresenter.StrokeInput.StrokeStarted += StrokeInput_StrokeStarted; inkCanvas.InkPresenter.StrokesErased += InkPresenter_StrokesErased; }Nous définissons ensuite des gestionnaires pour les événements PointerPressed, PointerMoved, et PointerReleased non traités transmis directement par InkPresenter.
Toutes les fonctionnalités de sélection sont implémentées dans ces gestionnaires, y compris le trait de lasso et le rectangle englobant.
// Handle unprocessed pointer events from modified input. // The input is used to provide selection functionality. // Selection UI is drawn on a canvas under the InkCanvas. private void UnprocessedInput_PointerPressed( InkUnprocessedInput sender, PointerEventArgs args) { // Initialize a selection lasso. lasso = new Polyline() { Stroke = new SolidColorBrush(Windows.UI.Colors.Blue), StrokeThickness = 1, StrokeDashArray = new DoubleCollection() { 5, 2 }, }; lasso.Points.Add(args.CurrentPoint.RawPosition); selectionCanvas.Children.Add(lasso); } private void UnprocessedInput_PointerMoved( InkUnprocessedInput sender, PointerEventArgs args) { // Add a point to the lasso Polyline object. lasso.Points.Add(args.CurrentPoint.RawPosition); } private void UnprocessedInput_PointerReleased( InkUnprocessedInput sender, PointerEventArgs args) { // Add the final point to the Polyline object and // select strokes within the lasso area. // Draw a bounding box on the selection canvas // around the selected ink strokes. lasso.Points.Add(args.CurrentPoint.RawPosition); boundingRect = inkCanvas.InkPresenter.StrokeContainer.SelectWithPolyLine( lasso.Points); DrawBoundingRect(); }Pour conclure le gestionnaire d’événements PointerReleased, nous effaçons tout le contenu de la couche de sélection (le trait du lasso), puis dessinons un rectangle englobant unique autour des traits d’encre englobés par la zone du lasso.
// Draw a bounding rectangle, on the selection canvas, encompassing // all ink strokes within the lasso area. private void DrawBoundingRect() { // Clear all existing content from the selection canvas. selectionCanvas.Children.Clear(); // Draw a bounding rectangle only if there are ink strokes // within the lasso area. if (!((boundingRect.Width == 0) || (boundingRect.Height == 0) || boundingRect.IsEmpty)) { var rectangle = new Rectangle() { Stroke = new SolidColorBrush(Windows.UI.Colors.Blue), StrokeThickness = 1, StrokeDashArray = new DoubleCollection() { 5, 2 }, Width = boundingRect.Width, Height = boundingRect.Height }; Canvas.SetLeft(rectangle, boundingRect.X); Canvas.SetTop(rectangle, boundingRect.Y); selectionCanvas.Children.Add(rectangle); } }Enfin, nous définissons des gestionnaires pour les événements InkPresenter StrokeStarted et StrokesErased.
Ces deux événements appellent simplement la même fonction de nettoyage pour effacer la sélection actuelle chaque fois qu’un nouveau trait est détecté.
// Handle new ink or erase strokes to clean up selection UI. private void StrokeInput_StrokeStarted( InkStrokeInput sender, Windows.UI.Core.PointerEventArgs args) { ClearSelection(); } private void InkPresenter_StrokesErased( InkPresenter sender, InkStrokesErasedEventArgs args) { ClearSelection(); }Voici la fonction permettant de supprimer l’ensemble de l’interface utilisateur de sélection du canevas de sélection au commencement d’un nouveau trait ou à l’effacement d’un trait existant.
// Clean up selection UI. private void ClearSelection() { var strokes = inkCanvas.InkPresenter.StrokeContainer.GetStrokes(); foreach (var stroke in strokes) { stroke.Selected = false; } ClearDrawnBoundingRect(); } private void ClearDrawnBoundingRect() { if (selectionCanvas.Children.Any()) { selectionCanvas.Children.Clear(); boundingRect = Rect.Empty; } }
Restitution d’une entrée manuscrite personnalisée
Par défaut, l’entrée manuscrite est traitée sur un thread d’arrière-plan à faible latence et rendue en cours, ou « humide », au fur et à mesure qu’elle est dessinée. Une fois le trait terminé (stylet ou doigt levé, ou bouton de la souris relâché), le trait est traité sur le thread d’interface utilisateur et rendu « sec » au calque InkCanvas (au-dessus du contenu de l’application et en remplaçant l’encre humide).
Vous pouvez remplacer ce comportement par défaut et contrôler complètement l’expérience d’entrée manuscrite en « séchage personnalisé » des traits d’encre humide. Bien que le comportement par défaut soit généralement suffisant pour la plupart des applications, il existe quelques cas où le séchage personnalisé peut être nécessaire, notamment :
- Gestion plus efficace des collections de traits d’encre volumineuses ou complexes
- Prise en charge plus efficace du panoramique et du zoom sur les canevas d’encre volumineuses
- Entrelacement de l’encre et d’autres objets, tels que des formes ou du texte, tout en conservant l’ordre z
- Séchage et conversion synchrone de l’encre en une forme DirectX (par exemple, une ligne droite ou une forme rastérisée et intégrée au contenu de l’application au lieu d’une couche InkCanvas distincte).
Le séchage personnalisé nécessite un objet IInkD2DRenderer pour gérer l’entrée manuscrite et la restituer dans le contexte d’appareil Direct2D de votre application Windows universelle, au lieu du contrôle InkCanvas par défaut.
En appelant ActivateCustomDrying (avant le chargement d’InkCanvas ), une application crée un objet InkSynchronizer pour personnaliser la façon dont un trait d’encre est rendu sec sur une SurfaceImageSource ou VirtualSurfaceImageSource.
SurfaceImageSource et VirtualSurfaceImageSource fournissent une surface partagée DirectX pour que votre application dessine et compose dans le contenu de votre application, bien que VSIS fournisse une surface virtuelle plus grande que l’écran pour un panoramique et un zoom performants. Étant donné que les mises à jour visuelles de ces surfaces sont synchronisées avec le thread d’interface utilisateur XAML, lorsque l’entrée manuscrite est rendue dans l’une ou l’autre, l’encre humide peut être supprimée simultanément d’InkCanvas.
Vous pouvez également personnaliser l’encre sèche sur un SwapChainPanel, mais la synchronisation avec le thread d’interface utilisateur n’est pas garantie et il peut y avoir un délai entre le rendu de l’encre dans votre SwapChainPanel et la suppression de l’entrée manuscrite dans InkCanvas.
Pour obtenir un exemple complet de cette fonctionnalité, consultez l’exemple d’entrée manuscrite complexe.
Notes
Séchage personnalisé et InkToolbar
Si votre application remplace le comportement par défaut du rendu d’entrée manuscrite de l’élément InkPresenter par une implémentation de séchage personnalisé, les traits d’encre restitués ne sont plus disponibles pour l’élément InkToolbar et les commandes d’effacement intégrées de l’élément InkToolbar ne fonctionneront pas comme prévu. Pour fournir des fonctionnalités d’effacement, vous devez gérer tous les événements de pointeur, effectuer le test de positionnement sur chaque trait et remplacer la commande intégrée « Effacer toutes les entrées manuscrites ».
Autres articles de cette section
| Rubrique | Description |
|---|---|
| Reconnaître les traits d’encre | Convertissez des traits d’encre en texte à l’aide de la reconnaissance de l’écriture manuscrite ou en formes à l’aide de la reconnaissance personnalisée. |
| Stocker et récupérer des traits d’encre | Stockez des données de traits d’encre dans un fichier GIF (Graphics Interchange Format) à l’aide des métadonnées intégrées ISF (Ink Serialized Format). |
| Ajouter un outil InkToolbar à une application d’entrée manuscrite Windows | Ajoutez un inkToolbar par défaut à une application manuscrite Windows, ajoutez un bouton de stylet personnalisé à InkToolbar et liez le bouton de stylet personnalisé à une définition de stylet personnalisée. |
Articles connexes
- Prise en main : Prise en charge de l’entrée manuscrite dans votre application Windows
- Gestion des entrées du pointeur
- Identification des périphériques d’entrée
- Spécification ISF (Ink Serialized Format).
API
Exemples
- Tutoriel prise en main : Prise en charge de l’entrée manuscrite dans votre application Windows
- Exemple d’encre simple (C#/C++)
- Exemple d’encre complexe (C++)
- Exemple d’encre (JavaScript)
- Exemple de livre de coloriage
- Exemple de notes de famille
- Exemple d’entrée de base
- Exemple d’entrée à faible latence
- Exemple de mode d’interaction utilisateur
- Exemples de visuels de focus
Exemples d’archive
Windows developer
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour