Stiftinteraktionen und Windows Ink in Windows-Apps

  • Artikel

Hero-Bild des Surface Pen.
Surface-Stift (zum Kauf im Microsoft Store verfügbar).

Übersicht

Optimieren Sie Ihre Windows-App für die Stifteingabe, um sowohl standardmäßige Zeigergerätefunktionen als auch die beste Windows Ink Für Ihre Benutzer bereitzustellen.

Hinweis

Der Schwerpunkt dieses Themas liegt auf der Windows Ink-Plattform. Informationen zur allgemeinen Behandlung von Zeigereingaben (ähnlich Maus-, Touch- und Touchpadeingaben) finden Sie unter Behandeln von Zeigereingaben.

Verwenden von Freihand in Ihrer Windows-App

Verwenden von Windows Pen und Ink zum Erstellen von stärker interaktiven Unternehmens-Apps

In Verbindung mit einem Zeichengerät bietet die Windows Ink-Plattform eine natürliche Möglichkeit, digitale handschriftliche Notizen, Zeichnungen und Anmerkungen zu erstellen. Sie können auf der Plattform Freihanddaten aus einem Eingabedigitalisierungsgerät erfassen, Freihanddaten generieren, verwalten und als letzte Striche auf dem Ausgabegerät rendern sowie über die Schrifterkennung in Text umwandeln.

Ihre App kann nicht nur die grundlegende Position und Bewegung des Stifts aufzeichnen, während der Benutzer schreibt oder zeichnet, sondern auch den variierenden Druck während des gesamten Strichs nachverfolgen und erfassen. Mit diesen Informationen, zusammen mit Einstellungen für Form und Größe der Stiftspitze, Drehung, Freihandfarbe und Zweck (einfache Freihandeingabe, Löschen, Hervorheben und Auswählen), können Sie dem Benutzer ermöglichen, auf ähnliche Weise wie mit einem Stift, Bleistift oder Pinsel auf Papier zu arbeiten.

Hinweis

Ihre App kann auch Freihandeingaben von anderen zeigerbasierten Geräten, z. B. Touchdigitalisierungs- und Mausgeräte, unterstützen. 

Die Freihandplattform ist sehr flexibel. Je nach Ihren Anforderungen unterstützt sie verschiedene Funktionalitätsgrade.

Richtlinien für die Benutzeroberfläche von Windows Ink finden Sie unter Inking controls.

Komponenten der Windows Ink-Plattform

Komponente BESCHREIBUNG
InkCanvas Ein XAML-UI-Plattformsteuerelement, das standardmäßig alle Eingaben von einem Stift als Freihandstriche oder Löschen von Freihandstrichen empfängt und anzeigt.
Weitere Informationen zur Verwendung von InkCanvas finden Sie unter Erkennen von Windows Ink-Strichen als Text und Speichern und Abrufen der Daten von Windows Ink-Strichen.
InkPresenter Ein CodeBehind-Objekt, das zusammen mit einem InkCanvas-Steuerelement instanziiert wird (über die InkCanvas.InkPresenter-Eigenschaft verfügbar gemacht). Dieses Objekt stellt alle Standardfreihandfunktionen bereit, die vom InkCanvas-Steuerelement zur Verfügung gestellt werden, sowie einen umfassenden Satz von APIs für zusätzliche Anpassung und Personalisierung.
Weitere Informationen zur Verwendung von InkPresenter finden Sie unter Erkennen von Windows Ink-Strichen als Text und Speichern und Abrufen der Daten von Windows Ink-Strichen.
InkToolbar Ein XAML-UI-Plattformsteuerelement, das eine anpassbare und erweiterbare Sammlung von Schaltflächen enthält, die freihandbezogene Features in einem zugeordneten InkCanvas aktivieren.
Weitere Informationen zur Verwendung der InkToolbar finden Sie unter Hinzufügen einer InkToolbar zu einer Freihand-App für Windows-Apps.
IInkD2DRenderer Ermöglicht das Rendern von Freihandstrichen im angegebenen Direct2D-Gerätekontext einer universellen Windows-App statt im standardmäßigen InkCanvas-Steuerelement. Dies ermöglicht die umfassende Anpassung der Freihandfunktionen.
Weitere Informationen finden Sie in diesem komplexen Freihandbeispiel.

Einfaches Freihandzeichnen mit „InkCanvas“

Um grundlegende Freihandfunktionen hinzuzufügen, platzieren Sie einfach ein InkCanvas UWP-Plattformsteuerelement auf der entsprechenden Seite in Ihrer App.

Das InkCanvas-Steuerelement unterstützt standardmäßig nur Freihandeingaben mit einem Stift. Die Eingabe wird entweder als Strich mit den Standardeinstellungen für Farbe und Stärke gerendert (ein schwarzer Kugelschreiber mit einer Stärke von 2 Pixeln) oder als Strichradierer behandelt (wenn die Eingabe von einer mit einer Löschschaltfläche geänderten Radiergummi- oder Stiftspitze stammt).

Hinweis

Falls keine Radiergummispitze bzw. -schaltfläche vorhanden ist, kann InkCanvas so konfiguriert werden, dass Eingaben mit der Stiftspitze wie Radierstriche behandelt werden.

In diesem Beispiel überlagert ein InkCanvas-Steuerelement ein Hintergrundbild.

Hinweis

Ein InkCanvas verfügt über die Standardeigenschaften Height und Width von 0 (null), es sei denn, es handelt sich um das untergeordnete Element eines Elements, das die größe seiner untergeordneten Elemente automatisch annimmt, z. B. StackPanel - oder Grid-Steuerelemente .

<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>

Diese Serie von Bildern zeigt, wie die Stifteingabe von diesem InkCanvas-Steuerelement gerendert wird.

Screenshot des leeren InkCanvas-Steuerelements mit einem Hintergrundbild. Screenshot: InkCanvas mit Freihandstrichen. Screenshot: InkCanvas mit einem gelöschten Strich.
Der leere InkCanvas mit einem Hintergrundbild. Die InkCanvas mit Freihandstrichen. Der InkCanvas mit einem ausradierten Strich (beachten Sie, dass jeweils der gesamte Strich und nicht nur auf einen Teil davon ausradiert wird).

Die vom InkCanvas-Steuerelement unterstützte Freihandfunktion wird von einem CodeBehind-Objekt mit dem Namen InkPresenter bereitgestellt.

Für die einfache Freihandeingabe müssen Sie sich nicht mit InkPresenter befassen. Wenn Sie jedoch das Freihandverhalten des InkCanvas-Steuerelements anpassen und konfigurieren möchten, müssen Sie auf das entsprechende InkPresenter-Objekt zugreifen.

Einfache Anpassung mit „InkPresenter“

Für jedes InkCanvas-Steuerelement wird ein InkPresenter-Objekt instanziiert.

Hinweis

Das InkPresenter-Objekt kann nicht direkt instanziiert werden. Stattdessen wird über die InkPresenter-Eigenschaft von InkCanvas darauf zugegriffen. 

Neben der Bereitstellung aller Standard-Freihandverhalten des entsprechenden InkCanvas-Steuerelements bietet InkPresenter einen umfassenden Satz von APIs für zusätzliche Strichanpassungen und eine differenzierte Verwaltung der Stifteingabe (standard und geändert). Dazu gehören Stricheigenschaften, unterstützte Eingabegerätetypen und die Angabe, ob Eingaben vom Objekt verarbeitet oder zur Verarbeitung an die App übergeben werden.

Hinweis

Die Standard-Freihandeingabe (von Stiftspitze oder Radiererspitze/-taste) wird nicht mit einem sekundären Hardwareangebot wie einer Stiftfasstaste, einer rechten Maustaste oder einem ähnlichen Mechanismus geändert.

Standardmäßig wird Freihandeingabe nur für Stifteingaben unterstützt. Hier konfigurieren wir InkPresenter, damit Eingabedaten von Stift und Maus als letzte Striche interpretiert werden. Wir legen auch einige anfängliche Freihandstrichattribute fest, die zum Rendern von Strichen in InkCanvas verwendet werden.

Um Maus- und Toucheingaben zu aktivieren, legen Sie die InputDeviceTypes-Eigenschaft von InkPresenter auf die gewünschte Kombination von CoreInputDeviceTypes-Werten fest.

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);
}

Attribute für letzte Striche können dynamisch entsprechend den Benutzereinstellungen oder App-Anforderungen festgelegt werden.

Hier kann der Benutzer aus einer Liste von Freihandfarben auswählen.

<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>

Anschließend behandeln wir Änderungen an der ausgewählten Farbe und aktualisieren die Attribute für letzte Striche entsprechend.

// 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);
    }
}

Diese Bilder zeigen, wie die Stifteingabe vom InkPresenter-Objekt verarbeitet und angepasst wird.

Screenshot: InkCanvas mit standardmäßigen schwarzen Freihandstrichen

Die InkCanvas mit standardmäßigen schwarzen Freihandstrichen.

Screenshot: InkCanvas mit vom Benutzer ausgewählten roten Freihandstrichen.

Die InkCanvas mit vom Benutzer ausgewählten roten Freihandstrichen.

Um zusätzlich zur Freihandeingabe und zum Löschen weitere Funktionen wie etwa die Strichauswahl bereitzustellen, muss die App bestimmte Eingaben identifizieren, die vom InkPresenter-Objekt ohne Verarbeitung zur Behandlung an die App weitergegeben werden.

Weitergabe der Eingabe für die erweiterte Verarbeitung

Standardmäßig verarbeitet InkPresenter alle Eingaben entweder als Freihand- oder Löschstrich, einschließlich Eingaben, die von einem sekundären Hardwareangebot wie einer Stiftfasstaste, einer rechten Maustaste oder ähnlichen geändert wurden. Benutzer erwarten jedoch in der Regel zusätzliche Funktionen oder ein geändertes Verhalten bei diesen sekundären Angeboten.

In einigen Fällen müssen Sie möglicherweise auch zusätzliche Funktionen für Stifte ohne sekundäre Angebote verfügbar machen (Funktionen, die normalerweise nicht der Stiftspitze zugeordnet sind), andere Eingabegerätetypen oder ein geändertes Verhalten basierend auf einer Benutzerauswahl auf der Benutzeroberfläche Ihrer App.

Das InkPresenter-Objekt kann zu diesem Zweck so konfiguriert werden, dass bestimmte Eingaben unverarbeitet bleiben. Diese unverarbeiteten Eingaben werden dann zur Verarbeitung an die App weitergegeben.

Beispiel: Verwenden einer nicht verarbeiteten Eingabe zum Implementieren der Strichauswahl

Die Windows Ink-Plattform bietet keine integrierte Unterstützung für Aktionen, die eine geänderte Eingabe erfordern, z. B. die Strichauswahl. Um Features wie diese zu unterstützen, müssen Sie eine benutzerdefinierte Lösung in Ihren Apps bereitstellen.

Im folgenden Codebeispiel (der gesamte Code befindet sich in den Dateien MainPage.xaml und MainPage.xaml.cs) wird beschrieben, wie Sie die Strichauswahl aktivieren, wenn die Eingabe mit einer Stiftfassschaltfläche (oder rechten Maustaste) geändert wird.

  1. Zunächst richten wir in „MainPage.xaml“ die Benutzeroberfläche ein.

    Hier fügen wir einen Zeichenbereich (unterhalb des InkCanvas-Steuerelements) zum Zeichnen der Strichauswahl hinzu. Durch die Verwendung einer eigenen Ebene zum Zeichnen der Strichauswahl bleiben das InkCanvas-Steuerelement und dessen Inhalt unverändert.

    Screenshot des leeren InkCanvas-Elements mit einer zugrunde liegenden Auswahlcanvas.

      <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>

  2. In „MainPage.xaml.cs“ deklarieren wir eine Reihe von globalen Variablen zum Speichern von Verweisen auf Aspekte der Auswahl-UI. Dies gilt insbesondere für den Auswahllassostrich und das umgebende Rechteck, das die ausgewählten Striche hervorhebt.

      // Stroke selection tool.
  private Polyline lasso;
  // Stroke selection area.
  private Rect boundingRect;

  3. Anschließend konfigurieren wir das InkPresenter-Objekt so, dass es Eingabedaten von Stift und Maus als Freihandstriche interpretiert. Zudem legen wir anfängliche Freihandstrichattribute zum Rendern von Freihandstrichen mit dem InkCanvas-Steuerelement fest.

    Vor allem geben wir mithilfe der InputProcessingConfiguration-Eigenschaft von InkPresenter an, dass alle geänderten Eingaben von der App verarbeitet werden sollen. Die geänderte Eingabe wird durch Zuweisen von InputProcessingConfiguration.RightDragAction mit dem Wert InkInputRightDragAction.LeaveUnprocessed angegeben. Wenn dieser Wert festgelegt ist, übergibt InkPresenter die Datei an die InkUnprocessedInput-Klasse , eine Gruppe von Zeigerereignissen, die Sie behandeln können.

    Wir weisen Listener für die nicht verarbeiteten PointerPressed-, PointerMoved- und PointerReleased-Ereignisse zu, die vom InkPresenter übergeben werden. Sämtliche Auswahlfunktionalität wird in den Handlern für diese Ereignisse implementiert.

    Schließlich weisen wir Listener für die Ereignisse StrokeStarted und StrokesErased des InkPresenter-Objekts zu. Wir verwenden die Handler für diese Ereignisse, um die Auswahl-UI zu bereinigen, wenn ein neuer Strich begonnen oder ein vorhandener Strich ausradiert wird.

    Screenshot der Freihandanpassungs-Beispiel-App mit freihandfarbenen Freihandstrichen mit standardmäßigen schwarzen Freihandstrichen

      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;
  }

  4. Anschließend definieren wir Handler für die nicht verarbeiteten Ereignisse PointerPressed, PointerMoved und PointerReleased , die von InkPresenter übergeben werden.

    Sämtliche Auswahlfunktionalität, einschließlich des Lassostrichs und des umgebenden Rechtecks, wird in diesen Handlern implementiert.

    Screenshot des Auswahl lasso.

      // 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();
    }

  5. Um den PointerReleased-Ereignishandler abzuschließen, löschen wir sämtlichen Inhalt (den Lassostrich) aus der Auswahlebene und zeichnen dann ein einzelnes umgebendes Rechteck um die letzten Striche, die sich im Lassobereich befinden.

    Screenshot des Auswahlbegrenzungs-Rect.

      // 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);
      }
    }

  6. Schließlich definieren wir Handler für die InkPresenter-Ereignisse StrokeStarted und StrokesErased.

    Diese beiden rufen einfach die gleiche Bereinigungsfunktion auf, um bei jeder Erkennung eines neuen Strichs die aktuelle Auswahl zu löschen.

      // 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();
  }

  7. Dies ist die Funktion zum Entfernen der gesamten Auswahl-UI aus dem Auswahlzeichenbereich, wenn ein neuer Strich begonnen oder ein vorhandener Strich ausradiert wird.

      // 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;
    }
  }

Benutzerdefiniertes Rendern von Freihandeingaben

Standardmäßig wird die Freihandeingabe in einem Hintergrundthread mit geringer Latenz verarbeitet und beim Zeichnen in Bearbeitung oder "nass" gerendert. Wenn der Strich abgeschlossen ist (der Stift oder Finger wurde angehoben oder die Maustaste losgelassen), wird er im UI-Thread verarbeitet und auf der InkCanvas-Ebene „trocken“ gerendert (über dem Anwendungsinhalt, wo er die nasse Freihandeingabe ersetzt).

Sie können dieses Standardverhalten überschreiben und die Freihanderfahrung vollständig steuern, indem Sie die nassen Freihandstriche "benutzerdefiniertes Trocknen" verwenden. Obwohl das Standardverhalten in der Regel für die meisten Anwendungen ausreichend ist, gibt es einige Fälle, in denen eine benutzerdefinierte Trocknung erforderlich ist, z. B.:

  • Effizientere Verwaltung großer oder komplexer Sammlungen von Freihandstrichen
  • Effizientere Unterstützung beim Schwenken und Zoomen auf großen Freihand-Leinwänden
  • Verschachtelung von Freihand- und anderen Objekten, z. B. Formen oder Text, unter Beibehaltung der Z-Reihenfolge
  • Synchrones Trocknen und Konvertieren von Freihand in eine DirectX-Form (z. B. gerastert und in Anwendungsinhalte integriert als separate InkCanvas-Schicht ).

Benutzerdefiniertes Trocknen erfordert anstelle des standardmäßigen InkCanvas-Steuerelements ein IInkD2DRenderer-Objekt, um die Freihandeingabe zu verwalten und im Direct2D-Gerätekontext der universellen Windows-App zu rendern.

Eine App erstellt durch Aufruf von ActivateCustomDrying (vor dem Laden des InkCanvas-Steuerelements) ein InkSynchronizer-Objekt, um zu definieren, wie ein letzter Strich trocken in einer SurfaceImageSource- oder VirtualSurfaceImageSource-Klasse gerendert wird.

Sowohl SurfaceImageSource als auch VirtualSurfaceImageSource bieten eine freigegebene DirectX-Oberfläche für Ihre App zum Zeichnen und Verfassen in den Inhalt Ihrer Anwendung, obwohl VSIS eine virtuelle Oberfläche bietet, die größer als der Bildschirm für das ausführende Schwenken und Zoomen ist. Da visuelle Updates für diese Oberflächen mit dem XAML-UI-Thread synchronisiert werden, kann die nasse Freihandeingabe gleichzeitig aus dem InkCanvas entfernt werden, wenn Freihand in beide Gerendert wird.

Sie können auch benutzerdefinierte trockene Freihandeingabe in einem SwapChainPanel verwenden, aber die Synchronisierung mit dem UI-Thread ist nicht garantiert, und es kann zu einer Verzögerung zwischen dem Rendern der Freihand in Ihrem SwapChainPanel und dem Entfernen von Freihand aus dem InkCanvas kommen.

Ein vollständiges Beispiel für diese Funktionalität finden Sie im Beispiel für komplexe Freihandeingaben.

Hinweis

Benutzerdefiniertes Trocknen und die InkToolbar
Wenn Ihre App das Standard-Renderverhalten für Freihandeingaben von InkPresenter mit einer benutzerdefinierten Trockenimplementierung außer Kraft setzt, sind die gerenderten Freihandstriche für die InkToolbar nicht mehr verfügbar und die integrierten Löschbefehle der InkToolbar funktionieren nicht wie erwartet. Damit Sie Löschfunktionen bereitstellen können, müssen Sie alle Zeigerereignisse verarbeiten, für jeden Strich einen Treffertest ausführen und den integrierten Befehl „Freihand vollständig löschen“ außer Kraft setzen.

Thema BESCHREIBUNG
Erkennen von Freihandstrichen Konvertieren Sie letzte Striche mit der Schrifterkennung in Text oder mit der benutzerdefinierten Erkennung in Formen.
Speichern und Abrufen von Freihandstrichen Speichern Sie Freihandstrichdaten mithilfe eingebetteter serialisierter Freihandformat-Metadaten (Ink Serialized Format, ISF) in einer GIF-Datei (Graphics Interchange Format).
Hinzufügen einer InkToolbar zu einer Windows-Freihand-App Fügen Sie eine Standard-InkToolbar zu einer Windows-App für Freihandeingaben hinzu, fügen Sie der InkToolbar eine benutzerdefinierte Stiftschaltfläche hinzu, und binden Sie die benutzerdefinierte Stiftschaltfläche an eine benutzerdefinierte Stiftdefinition.

APIs

Beispiele

Archivbeispiele