Auf Englisch lesen

Freigeben über


DynamicRenderer.EnableDataCache-Eigenschaft

Ruft einen Wert ab, der angibt, ob Datenzwischenspeicherung für das DynamicRenderer-Objekt aktiviert ist, oder legt diesen Wert fest.

Namespace:  Microsoft.StylusInput
Assembly:  Microsoft.Ink (in Microsoft.Ink.dll)

Syntax

'Declaration
Public Property EnableDataCache As Boolean
'Usage
Dim instance As DynamicRenderer
Dim value As Boolean

value = instance.EnableDataCache

instance.EnableDataCache = value
public bool EnableDataCache { get; set; }
public:
property bool EnableDataCache {
    bool get ();
    void set (bool value);
}
/** @property */
public boolean get_EnableDataCache()
/** @property */
public  void set_EnableDataCache(boolean value)
public function get EnableDataCache () : boolean
public function set EnableDataCache (value : boolean)

Eigenschaftenwert

Typ: System.Boolean
true , wenn die Datenzwischenspeicherung aktiviert ist, andernfalls false.

Hinweise

Durch Festlegen der EnableDataCache-Eigenschaft auf true können Sie die Situation behandeln, in der langsame Prozesse die Ausgabewarteschlange blockieren. Sollte ein Fenster ungültig sein, nachdem durch das DynamicRenderer-Objekt Striche gezeichnet wurden, kommt es ggf. zu einer Verzögerung, bevor die erfassten Striche erneut gezeichnet werden können. Wenn Sie die Striche von DynamicRenderer in einen Cache einfügen, können die Striche durch Aufrufen der Refresh-Methode erzeugt werden. Nachdem die Striche erfasst wurden, sollten Sie sie aus dem Cache freigeben, indem Sie die ReleaseCachedData-Methode aufrufen. Die Freigabe wird im Allgemeinen in der CustomStylusDataAdded-Methode ausgeführt.

Wenn Sie Striche so anzeigen möchten, wie sie gezeichnet sind, empfiehlt es sich, die EnableDataCache-Eigenschaft auf true festzulegen. Nachdem Sie sie einmal behandelt haben, ist eine Speicherung der Striche nicht weiter erforderlich. Speichern Sie die Datenbezeichner in diesem Fall im data-Parameter der CustomStylusDataAdded-Methode. Anschließend geben Sie die Daten frei, wenn Sie die zwischengespeicherten Striche nicht mehr benötigen.

Wenn die Eigenschaft true ist, müssen Sie die ReleaseCachedData-Methode für Striche aufrufen, die im Freihanderfassungsobjekt gespeichert wurden. Wenn false, müssen Sie die ReleaseCachedData-Methode nicht aufrufen. Der Nachteil beim Festlegen auf false besteht darin, dass beliebige Strichdaten, die ursprünglich dynamisch gerendert wurden, jedoch infolge von verschiedenen Vorgängen ungültig sind, nicht gerendert werden, bis die Strichdaten das Freihanderfassungsobjekt erreichen, um dort gerendert zu werden.

Durch Festlegen auf false werden die zwischengespeicherten Daten gelöscht. Daher wird eine Argumentausnahme ausgelöst, wenn der Code die ReleaseCachedData-Methode für ausstehende DynamicRendererCachedData-Objekte in der Warteschlange aufruft, nachdem die EnableDataCache-Eigenschaft auf false festgelegt wurde.

Weitere Informationen zu dieser Eigenschaft finden Sie unter Dynamic-Renderer Plug-ins.

Beispiele

In diesem C#-Beispiel wird das im Tablet- und Technologieabschnitt des Windows SDK bereitgestellte RealTimeStylus Ink Collection Sample erweitert. Nach dem Aktivieren von DynamicRenderer, theDynamicRenderer wird die EnableDataCache-Eigenschaft auf true festgelegt. Die DataInterest-Eigenschaft wird geändert, sodass DataInterestMask hinzugefügt wird. Die CustomStylusDataAdded-Methode sucht mit dem Bezeichner des DynamicRendererCachedDataGuid-Felds nach Daten und gibt diese danach frei, indem sie die CachedDataId-Eigenschaft der Daten verwendet.

// ...
private void InkCollection_Load(object sender, System.EventArgs e)
{
    // ...
    
    // Enable the real time stylus and the dynamic renderer
    myRealTimeStylus.Enabled = true;
    myDynamicRenderer.Enabled = true;  

    // Enable caching. If a refresh happens during inking, then
    // the stroke will still be displayed.  However, we have to 
    // release the cached data later.
    myDynamicRenderer.EnableDataCache = true;
    
    // ...
}
// ...
public DataInterestMask DataInterest
{
    get
    {
        return DataInterestMask.StylusDown |
               DataInterestMask.Packets |
               DataInterestMask.StylusUp |
               DataInterestMask.Error |
               DataInterestMask.CustomStylusDataAdded;
    }
}
public void CustomStylusDataAdded(RealTimeStylus sender, CustomStylusData data)
{
    // Release any cached data that's shown up.
    if (data.CustomDataId == DynamicRenderer.DynamicRendererCachedDataGuid)
    {
        DynamicRendererCachedData cachedData = (DynamicRendererCachedData) data.Data;
       cachedData.DynamicRenderer.ReleaseCachedData(cachedData.CachedDataId);
    }
}
// ...

In diesem C#-Beispiel werden die Daten von einem DynamicRenderer-Objekt in einen Cache eingefügt. Dadurch wird sichergestellt, dass eine Fensteraufhebung die Striche nicht löscht. Anschließend werden im Beispiel die Striche programmgesteuert gelöscht. Nach dem Aktivieren des DynamicRenderer-Objekts wird die theDynamicRenderer-Eigenschaft EnableDataCache auf true festgelegt. Im Paint-Ereignishandler wird DynamicRenderer.Refresh aufgerufen, um die Tablettstiftdaten im Cache neu zu zeichnen. Die DataInterest-Eigenschaft wird geändert, sodass DataInterestMask hinzugefügt wird. Die CustomStylusDataAdded-Methode sucht mit dem Bezeichner des DynamicRendererCachedDataGuid-Felds nach Daten und speichert diese in einer ArrayListcachedIds. Die ClearStrokes-Methode ruft ReleaseCachedData für alle Bezeichner in cachedIds auf und anschließend Refresh für Control auf.

using Microsoft.StylusInput;
using Microsoft.StylusInput.PluginData;
// ...
public class InkCollection : Form, IStylusAsyncPlugin
{ 
    private RealTimeStylus theRealTimeStylus;
    private DynamicRenderer theDynamicRenderer;
    private ArrayList cachedIds = new ArrayList();
// ...
    private void TempInkCollection_Load(object sender, System.EventArgs e)
    {
        theDynamicRenderer = new DynamicRenderer(this);
        theRealTimeStylus = new RealTimeStylus(this, true);

        ' Add the dynamic renderer to the synchronous plugin notification chain.
        ' Synchronous notifications occur on the pen thread.
        theRealTimeStylus.SyncPluginCollection.Add(theDynamicRenderer)

        // Add the dynamic renderer to the synchronous plugin notification chain.
        // Synchronous notifications occur on the pen thread.
        myRealTimeStylus.SyncPluginCollection.Add(myDynamicRenderer);

        // Add the form to the asynchronous plugin notification chain.  This plugin
        // will be used to collect stylus data into an ink object.  Asynchronous
        // notifications occur on the UI thread.
        myRealTimeStylus.AsyncPluginCollection.Add(this);

        // Enable the real time stylus and the dynamic renderer
        myRealTimeStylus.Enabled = true;
        myDynamicRenderer.Enabled = true;  

        // Enable caching. If a refresh happens during inking, then
        // the stroke will still be displayed.  However, we have to 
        // release the cached data later.
        myDynamicRenderer.EnableDataCache = true;
    }
// ...
    private void InkCollection_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
    {
        // Refresh the dynamic renderer, since it's possible that a stroke is being
        // collected at the time Paint occurs.  In this case, the portion of the stroke
        // that has already been collected will need to be redrawn.
        theDynamicRenderer.ClipRectangle = e.ClipRectangle;
        theDynamicRenderer.Refresh();
    }
// ...
    public DataInterestMask DataInterest
    {
        get
        {
            return DataInterestMask.CustomStylusDataAdded;
        }
    }

    public void CustomStylusDataAdded(RealTimeStylus sender, CustomStylusData data)
    {
        // Release any cached data that's shown up.
        if (data.CustomDataId == DynamicRenderer.DynamicRendererCachedDataGuid)
        {
            DynamicRendererCachedData cachedData = (DynamicRendererCachedData) data.Data;
            cachedIds.Add(cachedData.CachedDataId);
        }
    }
// ...
    private void ClearStrokes()
    {
        // Release all data
        foreach int dataId in cachedIds
        {
            theDynamicRenderer.ReleaseCachedData(dataId);
        }
        // Clear our stored list of Ids
        cachedIds.Clear();
        // Refresh the window
        this.Refresh()
    }
}

In diesem Microsoft Visual Basic .NET-Beispiel werden die Daten von einem DynamicRenderer-Objekt in einen Cache eingefügt. Dadurch wird sichergestellt, dass eine Fensteraufhebung die Striche nicht löscht. Anschließend werden im Beispiel die Striche programmgesteuert gelöscht. Nach dem Aktivieren des DynamicRenderer-Objekts wird die theDynamicRenderer-Eigenschaft EnableDataCache auf true festgelegt. Im Paint-Ereignishandler wird DynamicRenderer.Refresh aufgerufen, um die Tablettstiftdaten im Cache neu zu zeichnen. Die DataInterest-Eigenschaft wird geändert, sodass DataInterestMask hinzugefügt wird. Die CustomStylusDataAdded-Methode sucht mit dem Bezeichner des DynamicRendererCachedDataGuid-Felds nach Daten und speichert diese in einer ArrayListcachedIds. Die ClearStrokes-Methode ruft ReleaseCachedData für alle Bezeichner in cachedIds auf und anschließend Refresh für Control auf.

Imports Microsoft.StylusInput
Imports Microsoft.StylusInput.PluginData
' ...
Public Class TempInkCollector
    Inherits System.Windows.Forms.Form
    Implements Microsoft.StylusInput.IStylusAsyncPlugin

    Private theRealTimeStylus As RealTimeStylus
    Private theDynamicRenderer As DynamicRenderer
    Private cachedIds As ArrayList = New ArrayList()
' ...
    Private Sub TempInkCollector_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        theDynamicRenderer = New DynamicRenderer(Me)
        theRealTimeStylus = New RealTimeStylus(Me, True)

        ' Add the dynamic renderer to the synchronous plugin notification chain.
        ' Synchronous notifications occur on the pen thread.
        theRealTimeStylus.SyncPluginCollection.Add(theDynamicRenderer)

        ' Add the form to the asynchronous plugin notification chain.  This plugin
        ' will be used to collect stylus data into an ink object.  Asynchronous
        ' notifications occur on the UI thread.
        theRealTimeStylus.AsyncPluginCollection.Add(Me)

        ' Enable the real time stylus and the dynamic renderer
        theRealTimeStylus.Enabled = True
        theDynamicRenderer.Enabled = True
        theDynamicRenderer.EnableDataCache = True
    End Sub
' ...
    Private Sub InkCollector_Paint(ByVal sender As Object, ByVal e As System.Windows.Forms.PaintEventArgs) Handles MyBase.Paint
        ' Refresh the dynamic renderer, since it's possible that a stroke is being
        ' collected at the time Paint occurs.  In this case, the portion of the stroke
        ' that has already been collected will need to be redrawn.
        theDynamicRenderer.ClipRectangle = e.ClipRectangle
        theDynamicRenderer.Refresh()
    End Sub
'...
    Overridable Overloads ReadOnly Property DataInterest() As DataInterestMask Implements IStylusAsyncPlugin.DataInterest
        Get
            Return DataInterestMask.CustomStylusDataAdded
        End Get
    End Property
    Public Sub CustomStylusDataAdded(ByVal sender As Microsoft.StylusInput.RealTimeStylus, ByVal data As Microsoft.StylusInput.PluginData.CustomStylusData) Implements Microsoft.StylusInput.IStylusAsyncPlugin.CustomStylusDataAdded
        If data.CustomDataId.Equals(DynamicRenderer.DynamicRendererCachedDataGuid) Then
            ' Convert to DynamicRendererCachedData
            Dim cachedData As DynamicRendererCachedData = data.Data
            ' Add to list of ids.
            cachedIds.Add(cachedData.CachedDataId)
        End If
    End Sub
' ...
    Private Sub ClearStrokes()
        ' Release all data
        Dim dataId As Integer
        For Each dataId In cachedIds
            theDynamicRenderer.ReleaseCachedData(dataId)
        Next
        ' Clear our stored list of Ids
        cachedIds.Clear()
        ' Refresh the window
        Me.Refresh()
    End Sub
End Class

Plattformen

Windows Vista, Windows XP SP2, Windows Server 2003

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Versionsinformationen

.NET Framework

Unterstützt in: 3.0

Siehe auch

Referenz

DynamicRenderer-Klasse

DynamicRenderer-Member

Microsoft.StylusInput-Namespace

DynamicRendererCachedData

DynamicRenderer.ReleaseCachedData

DynamicRenderer.Refresh

Weitere Ressourcen

Dynamic-Renderer Plug-ins